Où définir membre de classe C++ fonction de modèle et de foncteurs que l'instancier?

J'ai une classe Foo qui est utilisée dans un petit projet indépendant. Il a une définition de la classe Foo.h la mise en œuvre de la classe de fonctions de membre dans un fichier d'implémentation Foo.cpp.

Première question - l'une des fonctions membres de la classe Foo est un modèle de la méthode Foo::doSomething(), est-il exact que la mise en œuvre de cette méthode doit figurer dans la déclaration de la fonction Foo.h ?

Le paramètre de modèle qui Foo::doSomething() sera instancié à l'un des deux types Functor - classe CalcA et CalcB.

Devrais-Je:

  • (A) la définition et la mise en œuvre des deux Foncteur classes tous ensemble dans Foo.cpp (où elles sont effectivement utilisées par la mise en œuvre d'autres Foo fonctions de membre d'appeler Foo::doSomething).
  • B) de mettre à la définition et à la mise en œuvre des deux Foncteur classes dans Foo.h.
  • (C) dois-je mettre de diviser la définition et la mise en œuvre des deux Foncteurs travers Foo.h et Foo.cpp comme le ferait avec une classe ordinaire?

OriginalL'auteur Paul Caheny | 2010-11-30

  1. 7

    Règle générale:

    Si foo::doSomething() est utilisé à l'extérieur foo.cpp (c'est à dire si c'est public ou protégé, en général), il faut aller dans l'en-tête.

    Si non, mettre dans le fichier cpp est parfaitement ok, et même une bonne idée (car il maintient l'encombrement loin de l'en-tête de fichier).

    Donc, si les foncteurs ne sont utilisées que dans le fichier cpp, par tous les moyens mis à la fonction de modèle. On peut toujours refactoriser les choses par la suite si cela change.

    Dans le cas où un modèle est nécessaire dans un seul fichier CPP, ensuite je mettrais la déclaration et la définition dans le fichier. Si c'est une fonction membre template et le reste de la classe est utilisé dans d'autres unités de traduction, je serais certainement mettre la définition dans le .h fichier. Je serais même d'être préoccupé par l'indéfini ou la mise en œuvre définies par le comportement si ce n'était pas fait.
    Je devrais avoir mentionné que, dans la question d'origine: oui Foo::doSomething() est un organisme privé de modèle de fonction membre de la classe Foo.
    Je ne suis pas votre point, pourriez-vous élaborer un peu? Dans mon cas, j'ai un privé modèle de fonction membre de la classe Foo, par conséquent, il n'est utilisé que par la mise en œuvre de la classe Foo dans Foo.cpp. Alors, cela semble correspondre avec le premier cas/phrase dans votre commentaire. Mais ma situation correspond à la description dans la deuxième phrase de votre commentaire ("fonction membre template et le reste de la classe est utilisé dans d'autres unités de traduction") où vous disent de le mettre dans un .h fichier.
    Mon avis est que vous devez par défaut de mettre la définition de la fonction membre template dans th .h de fichier dans votre cas. @Marcus ne sont pas d'accord avec moi. Vous aurez à faire un jugement d'appel.
    Même si son private, il semble un peu risqué & malodorante m'ont pas totalement définie par les objets flottant autour de différentes unités de traduction.

    OriginalL'auteur Macke

  2. 7

    Vous devez d'abord comprendre les modèles de mécanisme. Les modèles ne sont pas compilés, ils sont instanciés lorsqu'elles sont utilisées et leur instanciation est compilé. Ainsi, le compilateur a besoin de toute la définition du modèle dans chaque module à l'aide de la fonction de modèle, afin de les instancier d'abord en fonction des paramètres que vous avez réussi.

    Pour résoudre votre problème, il existe trois solutions, mais vous verrez qu'ils ont tous les deux mènent au même résultat.
    Soit vous mettez en œuvre votre ensemble de modèles à votre fichier d'en-tête à l'intérieur de la définition de la classe (que nous utilisons pour suffixe .hxx au lieu de .h précises ils contiennent des modèles définitions):

    //Foo.hxx

#ifndef __FOO_HXX__
#define __FOO_HXX__

class Foo {
  public:
   template <class T>    
   void bar(const T& t) {
      t.doSomething();
   }
 };
#endif

    Ou vous pouvez externaliser la définition de la classe, mais toujours dans le fichier d'en-tête:

    //Foo.hxx

#ifndef __FOO_HXX__
#define __FOO_HXX__

class Foo {
    public:
       template <class T>    
       void bar(const T&);
};

template <class T>
void Foo::bar(const T& t) {
   t.doSomething();
}
#endif

    Enfin, vous pouvez mettre en œuvre le modèle des méthodes les corps dans un fichier externe (avec le préfixe .cxx pour la même raison). Il contiendra des méthodes de corps, mais ne comprend pas les "Foo.hxx". Au lieu de cela, c'est "Foo.hxx" "Foo.cxx" après la définition de la classe. De cette façon, lorsque le compilateur résout la directive #include, il trouve l'ensemble de définition de modèle dans le même module, permettant d'instancier:

    //Foo.hxx

#ifndef __FOO_HXX__
#define __FOO_HXX__
class Foo {
    public:
       template <class T>    
       void bar(const T&);
};

#include "Foo.cxx"

#endif

//Foo.cxx
template <class T>
void Foo::bar(const T& t) {
   t.doSomething();
}

    Le choix entre ces 3 façons de mettre en œuvre des modèles est plutôt une question de lisibilité (et le goût).

    Les deuxième et troisième sont équivalents en termes de code généré, mais je préfère ne pas utiliser le fichier cxx solution, car elle conduit souvent à des erreurs stupides quand vous oubliez d'inverser l'inclure.

    En outre, bien connu des bibliothèques C++ comme STL ou de l'amplification de proposer leur code dans des fichiers d'en-tête uniquement, ce qui est un signe de bonne conception. En utilisant la définition externe à l'intérieur des en-têtes, vous clarifier la définition de votre classe. Vous aussi empêcher le compilateur automatiquement inline méthodes, ce qui peut parfois conduire à de mauvais résultats en fonction de Herb Sutter http://www.gotw.ca/gotw/033.htm

    merci pour la réponse. Je devrais l'ai mentionné dans ma question initiale que le modèle de la fonction membre dans ma situation est une fonction membre privée de la classe Foo. Séparément de celle donnée par les trois suggestions dans votre réponse, quels sont les avantages/inconvénients de chacun? La principale différence que je peux voir, c'est que dans votre première suggestion de la fonction de membre serait implicitement en ligne et dans les deux il ne serait pas, est-ce correct? Quels sont les avantages/inconvénients de la seconde & troisième ont les uns sur les autres?
    vous êtes en droit -> les méthodes définies dans une classe de corps sont automatiquement intégrées (voir stackoverflow.com/questions/1443982/... pour plus de détails sur inlining). J'ai édité ma réponse à ajouter les précisions que vous avez demandé. Espérons que cela vous a aidé.

    OriginalL'auteur jopasserat

  3. 1

    Mon défaut serait de mettre la définition de la fonction membre modèles de la droite dans le .h fichier, comme ceci:

    class Foo
{
public: 
  template<typename T> void DoSomething(T t);
};

//... later...

template<typename T>
void Foo::DoSomething(T t)
{
  //...
}

    Si c'est sous-optimal pour un cas particulier, alors j'aimerais prendre plus de mesures héroïques. En commençant par #include-ing .fichier inc à la définition, à la fin de l' .h fichier, ou peut-être même faire explicite instanciations dans le .fichiers cpp où j'avais besoin de la fonction de membre de modèles à utiliser.

    À mon humble avis c'est overdesigning un peu, si c'est une seule fonction. Mais c'est un bikeshed sujet de toute façon. 🙂
    Qu'est-ce qui est overdesigning?
    Je crois que je vois ce que vous êtes dit maintenant

    OriginalL'auteur John Dibling

  4. 1

    Le modèle de définition de la méthode devrait en effet être dans le fichier d'en-tête de la classe à laquelle il appartient.

    Comme ceci:

    class MyClass
{
    template <typename T>
    void foo(const T&)
    {
        //Definition
    }
};

    Ou comme ceci (à noter que le modèle de définition de la méthode peut être inclus à partir de fichier séparé après la déclaration de la classe)

    class MyClass
{
    template <typename T> void foo(const T&);
};

template <typename T>
void MyClass::foo(const T&)
{
    //Definition
}

    Le reste est dépend du style que vous avez accepté et vos besoins.

    Je mettrais le foncteur déclaration (ou même de la définition, si elles sont simples) dans l'en-tête si je les utilise pas seulement dans des Foo ou si Toto a comme membre de la classe.

    OriginalL'auteur Palmik