Pour & Cons de mettre tout le code dans les fichiers d'en-Tête dans le C++?

Raison [1] plus Rapide temps de compilation

Pas dans mes projets: les fichiers source (RPC) ne comprennent que les en-têtes (HPP) dont ils ont besoin. Donc quand j'ai besoin de recompiler un seul RPC en raison d'un changement minuscule, j'ai dix fois le même nombre de fichiers qui ne sont pas recompilés.

Vous devriez peut-être briser votre projet plus logique sources/en-têtes: Une modification dans la classe A de la mise en œuvre ne devrait PAS avoir besoin de la recompilation des implémentations de classe B, C, D, E, etc..

Raison[2]. Il évite les dépendances circulaires

Dépendances circulaires dans le code?

Désolé, mais je n'ai pas encore eu ce genre de problème à un problème réel: disons que A dépend de B, et B dépend de A:

struct A
{
   B * b ;
   void doSomethingWithB() ;
} ;

struct B
{
   A * a ;
   void doSomethingWithA() ;
} ;

void A::doSomethingWithB() { /* etc. */ }
void B::doSomethingWithA() { /* etc. */ }

Une bonne façon de résoudre le problème serait de briser cette source dans au moins une source de/en-tête de chaque classe (de manière similaire à Java, mais avec une seule source et un seul en-tête de chaque classe):

//A.hpp

struct B ;

struct A
{
   B * b ;
   void doSomethingWithB() ;
} ;

.

//B.hpp

struct A ;

struct B
{
   A * a ;
   void doSomethingWithA() ;
} ;

.

//A.cpp
#include "A.hpp"
#include "B.hpp"

void A::doSomethingWithB() { /* etc. */ }

.

//B.cpp
#include "B.hpp"
#include "A.hpp"

void B::doSomethingWithA() { /* etc. */ }

Donc, pas de problème de dépendance, et encore rapide temps de compilation.

Ai-je raté quelque chose?

Lorsque l'on travaille sur le "monde réel" des projets

dans un projet du monde réel, fichiers cpp ont tendance à inclure des en-têtes jusqu'à ce que vous ne pouvez pas comprendre qui dépend pour qui

De cours. Mais alors, si vous avez le temps de réorganiser les fichiers pour construire votre "un RPC" solution, alors vous avez le temps de nettoyer les têtes. Mes règles pour les en-têtes sont:

• briser en-tête pour les rendre aussi modulaire que possible
• Ne jamais inclure les en-têtes que vous n'avez pas besoin
• Si vous avez besoin d'un symbole, de l'avant-déclarer
• seulement si le ci-dessus a échoué, inclure l'en-tête

De toute façon, tous les en-têtes doivent être autonomes, ce qui signifie:

• Un en-tête comprennent tous besoin des en-têtes (et nécessaire uniquement les en-têtes - voir ci-dessus)
• un vide fichier CPP dont un en-tête doit compiler sans avoir besoin d'inclure quoi que ce soit d'autre

Cela permettra d'éliminer la commande de problèmes et les dépendances circulaires.

Est temps de compilation d'un problème? Alors...

Devrait moment de la compilation être vraiment un problème, je voudrais envisager:

• En utilisant les en-têtes précompilés (ce qui est assez utile pour les STL et BOOST)
• Diminuer le couplage à travers le PImpl idiome, comme expliqué dans http://en.wikipedia.org/wiki/Opaque_pointer
• Utilisation partagée en réseau compilation

Conclusion

Ce que vous faites est de ne pas tout mettre dans les en-têtes.

Vous êtes fondamentalement, y compris tous vos fichiers en une seule et unique source final.

Peut-être que vous êtes en train de gagner dans des conditions de pleine-projet de compilation.

Mais lors de la compilation pour un petit changement, vous aurez toujours perdre.

Lors du codage, je sais que je compile souvent de petits changements (si ce n'est que le compilateur valider mon code), puis un dernier temps, faire un changement de projet.

Je perdrais beaucoup de temps si mon projet a été organisée à votre façon.

Vous avez raison de dire que votre solution fonctionne. Il peut-être même pas les inconvénients pour votre projet actuel et de l'environnement de développement.

Mais...

Que d'autres ont dit, mettre votre code dans les fichiers d'en-tête des forces d'une compilation complète chaque fois que vous changer une ligne de code. Cela peut ne pas être un problème, mais encore votre projet peut devenir suffisamment gros pour le point de temps de compilation sera un problème.

Un autre problème, c'est quand le partage de code. Alors que vous pourriez ne pas être directement concerné pourtant, il est important de garder un maximum de code caché provenant d'un utilisateur potentiel de votre code. En mettant votre code dans le fichier d'en-tête, n'importe quel programmeur à l'aide de votre code doit regarder l'ensemble du code, alors que les intéressés à la façon de l'utiliser. Mettre votre code dans le fichier cpp permet de ne livrer un composant binaire (statique ou dynamique de la bibliothèque) et de son interface que les fichiers d'en-tête, qui peut être plus simple dans certains environnement.

C'est un problème si vous voulez être en mesure de transformer votre code actuel dans une bibliothèque dynamique. Parce que vous n'avez pas une bonne déclaration d'interface découplé du code actuel, vous ne serez pas en mesure de fournir un compilé dynamique de la bibliothèque et son utilisation de l'interface lisible fichiers d'en-tête.

Vous ne pouvez pas avoir ces problèmes encore, c'est pourquoi je disais que votre solution peut être ok dans votre environnement actuel. Mais il est toujours mieux d'être préparé à tout changement et à certaines de ces questions devraient être abordées.

PS: le C# ou Java, vous devez garder à l'esprit que ces langues ne sont pas à faire ce que vous dites. Ils sont en fait la compilation des fichiers de manière indépendante (comme les fichiers cpp) et les magasins de l'interface à l'échelle mondiale pour chaque fichier. Ces interfaces (et toutes les autres interfaces) sont ensuite utilisés pour lier l'ensemble du projet, c'est pourquoi ils sont capables de gérer les références circulaires. Parce que le C++ ne fait qu'une compilation de passer par fichier, il n'est pas en mesure à l'échelle mondiale des interfaces de magasin. C'est pourquoi vous devez les écrire explicitement dans les fichiers d'en-tête.

L'inconvénient évident pour moi, c'est que vous avez toujours à construire tout le code à la fois. Avec .cpp fichiers, vous pouvez avoir compilation séparée, de sorte que vous êtes seulement à la reconstruction de bits qui ont vraiment changé.

Une chose que vous êtes renoncer que j'aurais du mal à vivre sans est anonyme-espaces de noms.

Je trouve qu'ils sont incroyablement précieux pour la définition de la classe utilitaire fonctions qui doivent invisible en dehors de la classe de mise en œuvre de fichier. Ils sont aussi parfaits pour la tenue de toutes les données globales qui doivent être invisible pour le reste du système,comme une instance du singleton.

Un inconvénient de cette démarche est que vous ne pouvez pas le faire en parallèle de la compilation. Vous pourriez penser que vous êtes l'obtention d'un compiler plus vite maintenant, mais si vous avez plusieurs .fichiers cpp, vous pouvez construire en parallèle sur plusieurs de base sur votre propre ordinateur ou à l'aide d'un distribuée du système de construction comme distcc ou Incredibuild.

Je crois qu'à moins d'utiliser MSVC est pré-compilé en-têtes, et vous êtes à l'aide d'un Makefile ou un autre basée sur les dépendances de construction du système, la séparation des fichiers source doivent compiler plus vite lors de la construction de manière itérative. Depuis, mon développement est presque toujours itératif, je m'inquiète plus sur la façon rapide, il peut recompiler les modifications que j'ai apportées dans le fichier x.cpp que dans les vingt autres fichiers source que je n'ai pas changé. En outre, je fais des changements beaucoup plus fréquemment à la source des fichiers que je ne l'Api pour qu'ils changent moins fréquemment.

Concernant, dépendances circulaires. Je prendrais paercebal les conseils d'un peu plus loin. Il avait deux classes qui ont des pointeurs vers les uns des autres. Au lieu de cela, j'ai couru dans le cas le plus souvent lorsqu'une classe nécessite une autre classe. Lorsque cela se produit, je inclure le fichier d'en-tête de la dépendance dans le fichier d'en-tête de l'autre classe. Un exemple:

//foo.hpp
#ifndef __FOO_HPP__
#define __FOO_HPP__

struct foo
{
   int data ;
} ;

#endif //__FOO_HPP__

.

//bar.hpp
#ifndef __BAR_HPP__
#define __BAR_HPP__

#include "foo.hpp"

struct bar
{
   foo f ;
   void doSomethingWithFoo() ;
} ;
#endif //__BAR_HPP__

.

//bar.cpp
#include "bar.hpp"

void bar::doSomethingWithFoo()
{
  //Initialize f
  f.data = 0;
  //etc.
}

La raison que je comprend, ce qui est légèrement sans rapport avec dépendances circulaires, est que je pense qu'il y a des alternatives, y compris les fichiers d'en-tête de bon gré mal gré. Dans cet exemple, la structure de la barre de fichier source ne comprend pas la struct foo fichier d'en-tête. Ceci est fait dans le fichier d'en-tête. Cela a un avantage, c'est que d'un développeur à l'aide de la barre n'a pas besoin de connaître tous les autres fichiers que le développeur aurait besoin d'inclure pour utiliser ce fichier d'en-tête.

Bien, comme beaucoup l'ont souligné, il y a beaucoup d'inconvénients à cette idée, mais pour équilibrer un peu et de fournir un pro, je dirais que le fait d'avoir un code de bibliothèque entièrement dans les en-têtes de sens, puisqu'il sera indépendant des autres paramètres du projet, il est utilisé dans.

Par exemple, si l'on tente de rendre l'utilisation de différentes bibliothèques Open Source ils peuvent être mis à utiliser des approches différentes pour créer des liens vers votre programme - certains peuvent utiliser le système d'exploitation est chargée dynamiquement le code de bibliothèque, d'autres est lié statiquement; certains peuvent être configurés pour utiliser le multithreading, tandis que d'autres ne l'est pas. Et il peut très bien être une tâche écrasante pour un programmeur - surtout avec une contrainte de temps à essayer de classer ces approches incompatibles out.

Tout cela n'est cependant pas un problème lors de l'utilisation de bibliothèques qui sont contenues entièrement dans les en-têtes. "Ça marche" pour le bien-écrite de la bibliothèque.

Une chose que personne n'a abordé est celui de la compilation des fichiers volumineux nécessite un beaucoup de la mémoire. La compilation de l'intégralité de votre projet à la fois exiger un tel énorme espace de mémoire qu'il n'est tout simplement pas réalisable, même si vous pourriez mettre tout le code dans les en-têtes.

Le important de la philosophie de la Programmation Orientée Objet réside dans le fait d'avoir des données cacher conduisant à encapsulé classes avec la mise en œuvre est cachée par les utilisateurs. C'est principalement pour fournir une couche d'abstraction où les utilisateurs d'une classe utilisent essentiellement la mise à disposition du public des fonctions membres d'instance spécifique ainsi que les types statiques. Ensuite, le développeur de la classe est libre de modifier les implémentations réelles fourni les implémentations ne sont pas exposées aux utilisateurs. Même si la mise en œuvre est privée et a déclaré dans un fichier d'en-tête, la modification de la mise en œuvre exigera de tous dépendants de la base de code à la compilation. Considérant que, si la mise en œuvre (définition des fonctions membres) sont dans un code source (non-fichier d'en-tête), puis la bibliothèque est changé, et la variable dépendante de la base de code doit rétablir le lien avec la version révisée de la bibliothèque. Si cette bibliothèque est liée de façon dynamique un, comme une bibliothèque partagée puis en gardant la signature de la fonction (interface) même et la mise en œuvre changé ne nécessite pas de re-lier aussi. Avantage? Bien sûr.