Déclarations de type typedef, effet sur les temps de construction et conventions de dénomination

Question

Je suis curieux de connaître l'impact de mon approche typedef sur mes constructions.

Veuillez prendre en compte l'exemple suivant.

#include "SomeClass.h" 

class Foo 
{ 
    typedef SomeClass SomeOtherName; 

    SomeOtherName* storedPointer; 

    void setStoredPointer(SomeOtherName* s); 
} 

void Foo::setStoredPointer(SomeOtherName* s) 
{ 
    storedPointer = s; 
} 

Chaque fois que je me retrouve avec des situations comme ci-dessus, ce qui détermine le typedef dans le fichier d'en-tête et donc, ce qui nécessite que je #Include dans le fichier d'en-tête. Je crains que l'absence de déclarations à l'avance puisse entraîner des temps de construction plus longs.

D'après les commentaires de ce post:

Forward declaration of a typedef in C++

Je peux transmettre déclarer la classe, typedef une référence ou pointeur, puis #include dans le fichier .cpp. Cela devrait alors permettre des temps de construction plus rapides. Ai-je raison de mes conclusions à ce sujet?

Si oui, je finirais avec un typedef comme celui-ci:

typedef SomeClass* SomeOtherNamePtr; 
typedef SomeClass& SomeOtherNameRef; 
typedef const SomeClass* SomeOtherNameConstPtr; 
typedef const SomeClass& SomeOtherNameConstRef; 

Cela ne ressemble pas à un code très propre pour moi, et je pense que j'ai lu des articles/messages (pas nécessairement SO) recommandant contre cela.

Trouvez-vous cela acceptable? De meilleures alternatives?

---

Mise à jour: En utilisant la réponse de Michael Burr, j'ai pu résoudre le cas des pointeurs et des références seulement. Cependant, j'ai rencontré un problème en essayant de prendre le sizeof() dans ma fonction. Par exemple, disons que la classe a la fonction suivante:

//Foo.h 
class Foo 
{ 
    typedef class SomeClass SomeOtherName; 

    void doSomething(const SomeOtherName& subject) 
} 

//Foo.cpp 
#include "Foo.h" 
#include "SomeClass.h" 
void Foo::doSomething(const SomeOtherName& subject) 
{ 
    sizeof(subject); //generates error C2027: use of undefined type 'SomeClass'; 
    sizeof(SomeClass); //generates same error, even though using the sizeof() 
         //the class that has been #include in the .cpp. Shouldn't 
         //the type be known by now? 
} 

Sinon, cela fonctionnerait. J'utilise Microsoft Visual C++ 6.0. Est-ce un bug du compilateur ou est-ce en général contre la norme?

Dans l'exemple qui contient l'erreur, notez que sizeof (SomeClass) est la classe d'origine typedef, pas le nouveau type typedef créé dans Foo. Je suis surpris qu'en faisant une déclaration forward dans un typedef, je restreigne ma capacité à faire n'importe quoi avec la classe typedef.

---

Followup: Juste testé à l'aide du compilateur XCode et je crois que ma question sizeof était un problème visuel du compilateur C++ 6.0. Je suppose que le compilateur XCode est probablement correct, mais je n'ai rien d'autre à essayer pour le moment. Donc, même si c'était instructif, personnellement, je n'ai pas de chance sur ma tâche actuelle puisque la meilleure réponse ne fonctionne pas pour ma situation.

Answer 1

Est-ce que

typedef class SomeClass SomeOtherName; 

faire l'affaire pour vous? Par conséquent, l'unité de compilation qui utilise le typedef uniquement pour les pointeurs ou les références n'a pas besoin de #include l'en-tête SomeClass.

Answer 2

Suis-je correct dans mes conclusions à ce sujet?

Oui. L'une des réponses à la question que vous avez mentionné suggère que vous pouvez:

//forward declaration instead of #include "SomeClass.h" 
class SomeClass; 
//now this works even without #include "SomeClass.h" 
typedef SomeClass SomeOtherName; 

Cela ne ressemble pas à un code très propre pour me

Je ne vois pas que vos typedefs ajouter une valeur; Au lieu de cela, j'aurais probablement renvoyé SomeClass, puis j'aurais directement utilisé 'const SomeClass&'.