Éviter de déclarer des fonctions privées dans la catégorie fichiers d'en-tête C++(C++)

(En C++) j'ai une classe dont la structure est déclarée dans un fichier d'en-tête. Que fichier d'en-tête est inclus dans beaucoup de fichiers source, telle que quand j'edit, j'ai besoin de recompiler les fichiers.

La classe dispose d'un ensemble de fonctions privées qui ne sont appelés dans un fichier source. Actuellement, ils sont déclarés dans la structure de classe dans le fichier d'en-tête. Lorsque j'ajoute une nouvelle fonction de ce type, ou de modifier les arguments, il entraîne donc une recompilation des lots de fichiers. Je tiens à déclarer les fonctions quelque part d'autre, de sorte que seul le fichier qui définit les appelle est recompilé (pour gagner du temps). Ils doivent encore être en mesure d'accéder à l'intérieur de variables de classe, cependant.

Comment puis-je y parvenir?

  • Il y a des approches qui fonctionnent bien si j'avais écrit la classe à partir de zéro. Cependant, je ne suis pas commencer à partir de zéro; cette classe est déjà écrit.
InformationsquelleAutor user664303 | 2011-04-14
  1. 14

    Utiliser le pImpl idiome - Votre classe visible en garde un pointeur vers le réel classe et transfère les appels aux fonctions membres publiques.

    EDIT: En réponse aux commentaires

    //Foo.h:

class FooImpl; //Do *not* include FooImpl.h
class Foo {
public:
  Foo();
  ~Foo();
  //.. also need copy ctor and op=
  int bar();
private:
  FooImpl * Impl;
};

//FooImpl.h:

class FooImpl {
public:
  int bar() { return Bar; }
private:
  int Bar;
};

//Foo.cpp:

#include "FooImpl.h"

Foo::Foo() { Impl = new FooImpl(); }
Foo::~Foo() { delete Impl; }
int Foo::bar() { return Impl->bar(); }

    Garder la mise en œuvre effective de votre classe dans FooImpl - Foo devrait avoir une copie de la public membres de FooImpl et simplement transférer les appels vers ces. Tous les utilisateurs comprennent uniquement "Foo.h" - vous pouvez modifier toutes les informations privées de FooImpl sans que les utilisateurs de Foo de voir tous les changements.

    • Merci. C'est une bonne idée en général. Toutefois, dans ce cas je n'ai pas commencé à l'aide de ce cadre, de sorte que le déplacement de nécessiterait un vaste remaniement de ma classe, y compris la rédaction des wrappers pour l'ensemble de ses fonctions publiques. Je voudrais juste être en mesure d'expédier un sous-ensemble de fonctions privées de l'en-tête, sans trop de tracas.
    • L'héritage peut être une solution à ce problème particulier est l'un des ennuyeux, des sophismes de C++ de l'omi.
    • Suis-je en droit de penser qu'il faudra nécessairement une distribution de la classe pointeur d'instance, par exemple: ((priv_class *)this)->priv_func();. Ou est-il un moyen pour éviter cela?
    • L'avant de la déclaration .h: class FooImpl; class Foo { public: void bar(); FooImpl * Impl; }; .rpc: #include "FooImpl.h" ... void Foo::bar() { Impl->bar(); }
    • Je ne comprends pas comment FooImpl::bar() aurait accès aux membres privés de Foo. J'ai pu faire des Foo un ami de FooImpl, mais j'aurais quand même passer FooImpl::bar() un pointeur vers une instance de Foo.
    • Toto n'a pas privé les membres (à l'exception de l'Impl pointeur) - il a les mêmes fonctions membres publiques comme FooImpl. Voir mise à jour de la réponse de l'échantillon.

    InformationsquelleAutor Erik
  2. 4

    Il n'y a aucun moyen de déclarer des fonctions membres d'une classe à l'extérieur de la principale déclaration de classe. Donc, si vous voulez déclarer, à l'extérieur de la classe en question, les fonctions qui peuvent accéder aux variables membres d'une instance particulière de la classe, alors je ne vois pas d'autre alternative que de passer cette instance à la fonction. En outre, si vous voulez les fonctions pour être en mesure d'accéder au contenu privé et protégé les variables que vous aurez besoin de les mettre dans une nouvelle classe et de faire de la classe d'origine à un ami de que. E. g.

    en-tête.h:

    class FooImpl;

class Foo {
public:
   int bar();
   friend class FooImpl;
private:
   int var;
}

    impl.cpp:

    #include "header.h"

class FooImpl {
public:
   int bar(Foo &);
}

int FooImpl::bar(Foo &foo) {
return foo.var;
}

int Foo::bar() {
return FooImpl::bar(*this);
}
    • C'est ma compréhension, mais je ne suis pas sûr à 100%. Les observations reçues avec reconnaissance.
    • Vous avez encore int var dans class Foo. N'est pas le point de l'ensemble de la question est de le déplacer à class FooImpl?
    • Non, le point de l'ensemble de cette question était de savoir comment ajouter ou modifier privé fonctions dans une classe, sans changer l'en-tête. Si je déplace les variables privées à FooImpl puis j'ai aussi besoin de transmettre toutes les fonctions publiques à la classe. Voir mon premier commentaire à Erik de réponse à ce sujet.
    InformationsquelleAutor user664303
  3. 2

    Vous êtes à la recherche pour Compilateur De Pare-Feu, une.k.un. PIMPL?

    InformationsquelleAutor Nikolai Fetissov
  4. 1

    Créer une classe de base abstraite qui ne contient que les fonctions publiques et de référence dans vos en-têtes. Créer votre véritable classe comme une mise en œuvre ailleurs. Seuls les fichiers source qui ont besoin de créer votre besoin de classe pour voir l'application en-tête de classe.

    InformationsquelleAutor Neil Kirk