typedef c'est pas pour les variables mais pour les types

Bonjour !

J'ai un petit souci ;)

Je vous explique.

J'ai une structure ( singleton ) inclut dans un namespace avec un pointeur définit en externe.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

Design.hpp   namespace Design {   struct Data : public Singleton< Data > { // données } ;     extern Data * TheData ;   } // namespace Design

---

Code:

---

1 2 3 4 5 6 7

Design.cpp   #include "Design.hpp"   Design::Data * Design::TheData = nullptr ;   // etc

---

Dans une fonction en dehors du namespace "Design" j'utilise le pointeur "TheData" .

Je voulais savoir si au lieu de taper :

Code:

---

1 2 3

using namespace Design ;   TheData->Truc ;

---

ou

Code:

---

Design::TheData->Truc ;

---

je peux utiliser un typedef ?

J'ai évidemment essayé mais le compilateur ( Visual C++ 2008 )dit qu'il y a

une erreur de syntaxe( error C2649 ).

Voilà ce que j'ai essayé

Code:

---

1 2 3 4 5 6 7 8 9 10 11

1 : typedef Design::TheData data ;   2 : typedef Design::TheData * data ;   3 : typedef Design::Data * Design::TheData data ;   4 : typedef struct Design::TheData data ;   5 : typedef struct Design::TheData * data ;   // etc

---

En gros, je ne trouve pas la syntaxe correcte.

Je sais que ce que je désire faire est discutable, les premières solution sont suffisament correctes.

Mais je suis curieux .

Quelqu'un pourrait-il m'aider ?

Merci !

Bonjour et bienvenu,
un typedef, c'est sur le type. Ca ne peut pas te faire un synonyme sur une variable.
Pour cela il faudrait utiliser une référence :

Code:

---

1 2 3

Design::Data*& pt_synonyme = Design::TheData; // sur le pointeur Design::Data& synonyme = *Design::TheData; // sur sa valeur

---

Salut,

A vrai dire, tu te trompes completement dans l'utilisation de ton singleton...

L'idée est de partir sur une forme proche de
fichier d'en-tête (monSingleton.h)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

class MonSingleton { public: MonSingleton & /* ou * */ instance() { /* solution 1: pas de membre statique de la classe */ static MonSingleton ret; return ret // uniquement avec renvoi d'une référence /* solution 2: utilisation d'un membre statique de la classe */ if(! inst) inst=new MonSingleton; return *inst; // si renvoi d'une référence return inst; // si renvoi d'un pointeur } /* fonctions membres non statiques */ private: MonSingleton(){} ~MonSingleton(){} /* uniquement pour la solution 2 */ static MonSingleton * inst;   }

---

fichier d'implémentation (monSingleton.cpp)

Code:

---

MonSingleton * MonSingleton::inst = NULL

---

et, chaque fois que tu as besoin de ton singleton, travailler sous la forme de

Code:

---

MonSingleton::instance().laFonctionMembreQuiTInteresse(/* arguments éventuels */ );

---

Voire, si tu prévois d'avoir plusieurs singletons, de centraliser les comportements propres au singleton (le fait passer par la fonction membre statique instance() ) dans une classe template (pour que chaque singleton puisse vivre indépendamment des autres) sous une forme proche de
fichier d'en-tête (TSingleton.h)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

template <class T> class TSingleton {   public: TSingleton & /* ou * */ instance() { /* solution 1: pas de membre statique de la classe */ static TSingleton ret; return ret // uniquement avec renvoi d'une référence /* solution 2: utilisation d'un membre statique de la classe */ if(! inst) inst=new T; return *inst; // si renvoi d'une référence return inst; // si renvoi d'un pointeur } /* fonctions membres non statiques */ protected: MonSingleton(){} ~MonSingleton(){} private: /* uniquement pour la solution 2 */ static T * inst;   }; template class T> T * TSingleton<T>::inst = NULL;

---

dont l'utilisation utilisera le CRTP sous une forme proche de
#include <TSingleton.h>

Code:

---

1 2 3 4 5 6 7 8 9

class MonSingleton : public TSingleton<MonSingleton> { friend class TSingleton<MonSingleton>; public: /* les fonctions membres intéressantes */ private: MonSingleton(){} ~MonSingleton(){} };

---

mais qui sera utilisé de manière exactement similaire.

Salut ,

Merci à vous pour vos réponses claires et précises ;)

3DArchi :

J'ai désormais compris l'utilisation des typedef.

Je vais donc utiliser cette syntaxe :

Code:

---

Design::Data& synonyme = *Design::TheData ;

---

koala01 :

Merci pour ton explication !

J'utilise un moteur de jeu ( C4Engine, un peu de pub ).

Dans lequel une classe Singleton est déjà implémentée.

La license ne me permet pas de divulguer le code.....

je fait :

Code:

---

new Design::Data ;

---

pour créer l'instance.

et je détruit le pointeur global pour la détruire.

Le code du constructeur est le suivant :

Code:

---

1 2 3 4 5 6 7 8

Design.cpp   #include "Design.hpp"   Design::Data * Design::TheData = nullptr ;   Design::Data::Data( void ) : public C4::Singleton< Data >( TheData ) { }

---

Ce doit être un modéle connu...

Il est vrai que rien ne m'empêche, de créer une autre classe Singleton, qui me

renverrait directement une référence sur l'instance, je vais y penser et m'y

atteler, si le besoin se fait sentir.

:coucou:

En fait, tout semble indiquer que la classe template C4::Singleton présente une forme proche de la deuxième que j'ai présentée...


[EDIT]Tu devrais donc vérifier la présence d'une fonction déclarée statique renvoyant un pointeur vers le type d'argument template et, vraisemblablement nommée instance (ou similaire) [/EDIT]

De ce fait, tu devrais, idéalement, définir le constructeur et le destructeur en accessibilité privée et déclarer le type C4::Singleton<Data> amie de ta classe Data.

Attention, je parle bien de les définir, c'est à dire de les déclarer et de leur donner un corps ;)

Le but est double:
En rendant ces deux fonctions particulières privées (mais en le faisant exister quand même),

1. tu t'assure que personne (hormis la classe... Singleton au travers de sa fonction membre instance ou similaire) ne sera en mesure de créer une autre instance de l'objet
2. En rendant le destructeur privé (mais en le faisant exister quand même), tu t'assure que personne (hormis la classe... Singleton au travers d'une éventuelle fonction destroy ou similaire, si elle existe) ne pourra décider de détruire l'instance unique lorsqu'elle existe.

En effet, en l'état actuel, tel que tu utilise ta classe data, tu n'a absolument pas de certitude que ta classe n'existe que sous la forme d'une instance unique.

Qu'il te suffise d'écrir un code aussi simple que

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#include <Data.h> int main() { Desing::Data * ptr1=new Desing::Data; Desing::Data * ptr2=new Desing::Data; std::cout<<"Adresse de ptr1 : "<<ptr1<<std::endl <<"Adresse de ptr2 : "<<ptr2<<std::endl; delete ptr1; delete ptr2; return 0; }

---

Si, vraiment, ta classe Data était un singleton, les deux adresses devraient être identiques, vu que c'est le but d'un singleton.

Or, je suis près à parier mon caleçon que tu obtiendra une sortie indiquant deux adresses différentes ;) :P

Hello koala01,

Citation:

---

Envoyé par koala01

Tu devrais donc vérifier la présence d'une fonction déclarée statique renvoyant un pointeur vers le type d'argument template et, vraisemblablement nommée instance (ou similaire)

---

En fait, il n'y a qu'un constructeur et un destructeur en accés protégé .

J'accède à la classe grâce au pointeur global. Donc il n'y a pas ce genre de fonction.

Citation:

---

Envoyé par koala01

En fait, tout semble indiquer que la classe template C4::Singleton présente une forme proche de la deuxième que j'ai présentée...

---

En effet. ;)

Citation:

---

Envoyé par koala01

En effet, en l'état actuel, tel que tu utilise ta classe data, tu n'a absolument pas de certitude que ta classe n'existe que sous la forme d'une instance unique.

---

Je ne peux créer qu'une instance, car le constructeur du singleton ne prend qu'un pointeur en paramètre.

En cherchant bien ce modéle doit bien avoir une faille mais encore faut-il
vouloir l'exploiter :koi:

A plus !