Déclarations de typedef, effets sur les temps de construction et conventions de nommage

Question

Je suis curieux de l'impact de mon approche typedef sur mes builds.

Veuillez considérer 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 dans une situation semblable à celle décrite ci-dessus, cela entraîne le typedef dans le fichier d’en-tête et nécessite donc que je l’inclue dans le fichier d’en-tête. Je crains que le manque de déclarations anticipées ne cause des temps de construction plus longs.

D'après les commentaires de cet article:

Déclaration anticipée d'une typedef en C ++

Je peux transférer la déclaration de la classe, saisir une référence ou un pointeur, puis inclure le fichier dans le fichier .cpp. Cela devrait alors permettre des temps de construction plus rapides. Ai-je raison dans mes conclusions à ce sujet?

Si oui, je me retrouverais avec un type de fichier tel que:

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

Cela ne me semble pas être un code très clair, et je pense avoir lu des articles / postings (pas nécessairement sur SO) qui le recommandent.

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 uniquement. Cependant, j'ai rencontré un problème en essayant de prendre la taille de () dans ma fonction. Par exemple, supposons que la classe ait 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.

//Foo.h
class SomeClass;
class Foo
{
    void doSomething(const SomeClass& subject)
}

//Foo.cpp
#include "Foo.h"
#include "SomeClass.h"
void Foo::doSomething(const SomeClass& subject)
{
    sizeof(subject);
    sizeof(SomeClass);
}

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, veuillez noter qu'un sizeof (SomeClass) est la classe d'origine en cours de typedef, et non le nouveau type de typedef en cours de création dans Foo. Je suis surpris qu’en faisant une déclaration en aval dans un typedef, je ne sois plus capable de faire quoi que ce soit avec la classe en cours de typedef.

Suivi: Je viens de le tester en utilisant le compilateur XCode et je crois que ma question sizeof était un problème de compilateur Visual C ++ 6.0. J'imagine que le compilateur XCode est probablement correct, mais je n'ai rien d'autre à essayer pour le moment. Ainsi, même si cela a été informatif, je suis personnellement malchanceux dans mon travail actuel, car la meilleure réponse ne fonctionne pas dans mon cas.

Answer 1

Serait

typedef class SomeClass SomeOtherName;

faites le tour pour vous?

Avec cela, l'unité de compilation utilisant 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. Une des réponses à la question que vous avez évoquée 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;

  

Pour moi, cela ne ressemble pas à un code très propre

Je ne vois pas que vos typedefs ajoutent de la valeur; je préférerais probablement déclarer SomeClass , puis utiliser directement ' const SomeClass & '.