typedef appelé de façon statique

Bonjour,

Contexte:
- 5 classes sont en jeux, soit IPrimitive, Rectangle, Triangle, Texte et Coordinates2f
- Rectangle, Triangle et Texte héritent de IPrimitive et doivent redéfinir la méthode get2DCoordinates2f() qui retourne un vecteur (vector<Coordinates2f*>).

Problème:
Je dois répéter à toutes les fois vector<Coordinates2f*>, soit pour la création du vecteur comme tel ou pour la création de mon itérateur.

Ma solution:
J'ai créé une classe Constants qui possède des constructeurs/destructeurs privés et je fais une redéfinition de type (typedef). Voici la classe Constants:

Code:

---

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

#ifndef CONSTANTS_H_ #define CONSTANTS_H_ #include <vector>   using namespace std;   class Constants{ public: typedef vector<Coordinates2f*> type_listCoord;   private: Constants(); virtual ~Constants();   };   #endif /*CONSTANTS_H_*/

---

Donc pour me créer une liste qui contient des pointeurs de Coordinates2f. Je fais:

Code:

---

Constants::type_listCoord *maListe = new Constants::type_listCoord;

---

Et ça fonctionne! :D

Le tout pour en arrivé à: "Est-ce une bonne façon de faire?"

En passant, je suis Intermédiaire/avancé en Java, et Débutant/avancé en C++. Certaines fois, des choses sont faites en Java, mais ne peuvent être faites en C++.

Merci à l'avance

Je ne vois pas pourquoi se donner autant de peine pour un typedef.
Pourquoi l'encapsuler dans une classe?
Cette classe sera elle complété?
J'ai pas du tout comprendre.

+1

Si tu ne souhaite qu'un "sucre syntaxique" (facilité d'écriture)

il te suffit d'un

Code:

---

typedef vector<Coordinates2f*> type_listCoord;

---

sinon excuse moi, mais je trouve que vector<Coordinates2f*> est 100 fois plus clair pas beaucoup plus pénible à écrire que Constants::type_listCoord ...

de plus, rarement besoin d'utiliser new...

Merci à seriousme et Swoög pour leur réponse rapide.

Dans mon cas, je suis daccord que l'utilité de faire ce genre de manoeuvre n'est pas si bénéfique. Mais imaginez vous, par exemple, que vous avez une 30aine de classes qui s'échange des vecteurs, contenant tous le même type d'objet. Pour le moment, les vecteurs contiennent des pointeurs vers des objets, mais disons que demain, vous voulez qu'ils contiennent la référence. Dans ce cas, il faut aller changer dans toutes les classes la définition des vecteurs.

Est-ce plus claire?

Merci

Pourquoi l'encapsuler?

Citation:

---

Envoyé par matrox

Pour le moment, les vecteurs contiennent des pointeurs vers des objets, mais disons que demain, vous voulez qu'ils contiennent la référence.

---

Les types stockés par les conteneurs de la STL doivent être copiables, les références ne le sont pas, elles sont impossibles à utiliser dans ce cas là... (dommage ;) )

sinon, pour ton exemple, si tu changes le type stcoké, il te faudra de toute façons remanier tout ton code... donc c'est du pareil au même...

Et puis si c'est juste pour changer le type en lui même (que les autres comportement ne sont pas modifier) un petit replace all in project, et hop, plus de problèmes...

et si t'aime pas cette solution, il reste la remarque de seriousme : POURQUOI l'encapsuler ? c'est jamais qu'un type comme un autre, un petit typedef à la fin du .h de Coordinates2f et basta...

Ok, j'avoue que ça l'a du sens. Merci bien.

Mais, juste avant de clore cette discussion, j'aimerais bien savoir de quelle façon l'on peut rendre une variable global. Par exemple, je veux que PI = 3.1416 dans l'ensemble de mon projet, mais je veux la définir à un seul endroit. Comment faire?

Merci

tu as deux choix... l'encapsulation dans une classe ou un namespace si ça se justifie (exemple, un namespace ou une classe Maths qui contiendrait pi, e, les facteurs de conversion radian/degré, certaines racines irrationnelles, etc...)

ou alors en variables pûrement globale (très déconseillée... souvent la sémantique de ce type de variable témoigne d'une mauvaise modélisation en C++)

J'ajouterais que l'encapsulation dans une classe est toujours préférable (même sémantiquement parlant) à celle dans un namespace

dans le cas d'encapsulation dans une classe, ça se déclare très simplement : dans la signature de la classe :

Code:

---

static TYPE VAR;

---

puis dans le cpp de la classe :

Code:

---

1 2 3 4

TYPE CLASS::VAR( VALEUR ); //ou TYPE CLASS::VAR = VALEUR; //les deux syntaxes étant équivalentes

---

dans le cas d'encapsulation dans un namespace ou d'une variable globale :
déclarer la variable dans un .h :

Code:

---

extern TYPE VAR;

---

puis la définir dans un .cpp :

Code:

---

1 2	TYPE VAR(VALEUR); TYPE VAR = VALEUR;

---

ensuite, ça se gère comme un couple .h/.cpp classique, le .h étant à inclure à chaque fois que tu as besoin de la variable ;)

Ok, merci pour tous Swoög.