Ce qui devrait aller dans une .h fichier?

Fait est que, en C++, c'est un peu plus compliqué que les en-tête C/organisation de la source.

Que fait le compilateur voir?

Le compilateur voit une grande source (.rpc) fichier de avec ses en-têtes inclus. Le fichier source est l'unité de compilation qui sera compilé dans un fichier objet.

Alors, pourquoi est-têtes nécessaires?

Parce qu'une unité de compilation pourrait avoir besoin d'informations sur la mise en œuvre dans une autre unité de compilation. Donc, on peut écrire par exemple la mise en œuvre d'une fonction à une seule source, et écrire la déclaration de cette fonction dans une autre source ayant besoin de l'utiliser.

Dans ce cas, il existe deux copies de la même information. Qui est le mal...

La solution est de partager quelques détails. Alors que la mise en œuvre doit rester dans la Source, la déclaration du partage des symboles, comme des fonctions ou de la définition de structures, classes, les énumérations, etc., pourrait avoir besoin d'être partagé.

Les en-têtes sont utilisés pour mettre ceux partagé des détails.

Déplacer à l'en-tête les déclarations de ce que doivent être partagées entre plusieurs sources

Rien de plus?

En C++, il y a quelques autres choses qui pourraient être mis dans l'en-tête parce que, ils doivent, eux aussi, être partagé:

• de code en ligne
• modèles
• constantes (généralement ceux que vous souhaitez utiliser à l'intérieur des commutateurs...)

Déplacer vers la tête de TOUT ce qui doit être partagé, y compris partagé implémentations

T-il à dire alors qu'il pourrait y avoir des sources à l'intérieur de l'en-tête?

Oui. En fait, il ya beaucoup de choses différentes qui pourraient être à l'intérieur d'un "en-tête" (c'est à dire partagé entre les sources).

• Déclaration
• déclarations/définition de fonctions/structures/classes/templates
• mise en œuvre en ligne et basé sur un modèle de code

Cela devient compliqué, et dans certains cas (les dépendances circulaires entre les symboles), impossible de le garder dans l'en-tête.

En-têtes peut être décomposé en trois parties

Cela signifie que, dans un cas extrême, vous pourriez avoir:

• une déclaration anticipée en-tête
• une déclaration/définition de l'en-tête
• de mise en œuvre de l'en-tête
• de mise en œuvre de la source de

Imaginons que nous avons basé sur un modèle MyObject. Nous pourrions avoir:

//- - - - MyObject_forward.hpp - - - - 
//This header is included by the code which need to know MyObject
//does exist, but nothing more.
template<typename T>
class MyObject ;

.

//- - - - MyObject_declaration.hpp - - - - 
//This header is included by the code which need to know how
//MyObject is defined, but nothing more.
#include <MyObject_forward.hpp>

template<typename T>
class MyObject
{
   public :
      MyObject() ;
   //Etc.
} ;

void doSomething() ;

.

//- - - - MyObject_implementation.hpp - - - - 
//This header is included by the code which need to see
//the implementation of the methods/functions of MyObject,
//but nothing more.
#include <MyObject_declaration.hpp>

template<typename T>
MyObject<T>::MyObject()
{
   doSomething() ;
}

//etc.

.

//- - - - MyObject_source.cpp - - - - 
//This source will have implementation that does not need to
//be shared, which, for templated code, usually means nothing...
#include <MyObject_implementation.hpp>

void doSomething()
{
   //etc.
} ;

//etc.

Wow!

Dans la "vraie vie", il est généralement moins compliqué. La plupart du code aura seulement un simple en-tête/source de l'organisation, avec quelques inline code dans la source.

Mais dans d'autres cas (basé sur un modèle d'objets de savoir les uns des autres), j'ai dû avoir pour chaque objet séparé de déclaration et de mise en œuvre des en-têtes, avec un vide de source y compris ceux en-têtes pour m'aider à voir quelques erreurs de compilation.

Une autre raison pour briser les en-têtes dans un en-tête différent pourrait être pour accélérer la compilation, la limitation de la quantité de symboles analysée au strict nécessaire, et en évitant d'inutiles recompilation d'une source qui ne s'occupe que de la déclaration anticipée lorsqu'une ligne de la méthode de la mise en œuvre changé.

Conclusion

Vous devriez faire de votre code d'organisation à la fois aussi simple que possible, et aussi modulaire que possible. Mettre autant que possible dans le fichier source. Seulement exposer dans les en-têtes de ce qui doit être partagée.

Mais le jour où vous aurez circulaire dépendances entre basé sur un modèle d'objets, ne soyez pas surpris si votre code d'organisation devient un peu plus "intéressant" que la plaine en-tête/organisation de la source...

^_^

Ce compile en rien (zéro binaire de l'empreinte) va dans le fichier d'en-tête.

Variables ne compile pas en rien, mais les déclarations de type n' (coz ils ne décrivent comment les variables de comportement).

fonctions ne sont pas, mais les fonctions inline faire (ou macros), parce qu'ils produisent du code que là où il est appelé.

modèles ne sont pas de code, ils ne sont qu'une recette pour la création de code. donc, ils vont aussi dans les h des fichiers.

Votre classe et les déclarations de fonction en plus de la documentation, et les définitions pour les fonctions/méthodes (bien que certains préfèrent mettre en séparer .inl fichiers).

le fichier d'en-tête (.h) devrait être pour les déclarations de classes, des structures et de ses méthodes, prototypes, etc. La mise en œuvre de ces objets sont fabriqués en rpc.

dans .h

    class Foo {
    int j;

    Foo();
    Foo(int)
    void DoSomething();
}

L'en-tête Définit quelque chose, mais ne dit rien au sujet de la mise en œuvre. ( À l'exclusion des Modèles dans cette "metaforemc".

Avec cela dit, vous devez répartir les "définitions" en sous-groupes, il y a, dans ce cas, deux types de définitions.

• Vous définissez la "mise en page" de votre structure, en disant qu'autant qu'il est requis par les entourant l'utilisation de groupes.
• Les définitions d'une variable, une fonction ou une classe.

Maintenant, je veux bien sur parler le premier sous-groupe.

L'en-tête est là pour définir la mise en page de votre structure afin d'aider le reste de l'utilisation du logiciel, la mise en œuvre. Vous pourriez le voir comme une "abstraction" de votre mise en œuvre, qui est vaughly dit, mais, je pense que cela correspond assez bien dans ce cas.

Comme les précédentes affiches ont dit et montré, vous déclarez privé et public, les domaines d'utilisation et leurs en-têtes, ce qui inclut également privés et publics des variables. Maintenant, je ne veux pas entrer dans la conception du code ici, mais, vous pourriez envisager ce que vous mettez dans vos têtes, parce que c'est la Couche entre l'utilisateur final et la mise en œuvre.

En-tête (.h)

• Macros et comprend le nécessaire pour les interfaces (aussi peu que possible)
• La déclaration des fonctions et des classes
• Documentation de l'interface
• Déclaration de fonctions inline/méthodes, si tout
• extern aux variables globales (le cas échéant)

Corps (.rpc)

• Reste de macros et comprend
• Inclure l'en-tête du module
• Définition de fonctions et de méthodes de
• Variables globales (le cas échéant)

En règle générale, vous mettez le "partage" de la partie du module sur le .h (la partie que d'autres modules doit être en mesure de voir) et le "non partagé" de la partie sur le .rpc

PD: Oui, j'ai inclus des variables globales. J'ai utilisé quelques fois et il est important de ne pas les définir sur les en-têtes, ou vous aurez beaucoup de modules, chacun de définir sa propre variable.

EDIT: Modifié d'après le commentaire de David