Si je crée une classe avec de petites fonctions qui ne font pas grand chose, est-il acceptable de simplement les mettre dans le fichier d'en-tête? Donc, pour une classe particulière, ce n'est que le .h sans page .CPP pour y aller. P>
5 Réponses :
Oui, c'est acceptable. Cela compilera certainement. Mais aussi, si cela rend le Code Nettoyant, cela peut être bon. La plupart des définitions de modèles sont déjà comme celles-ci par nécessité, vous ne faites donc rien d'inouïe. Il peut y avoir des inconvénients de cette classe repose cependant sur d'autres classes. Si vous finissez par avoir à inclure toute la définition dans d'autres fichiers qui utilisent la classe, cela peut entraîner une période de compilation supplémentaire par rapport à une déclaration de classe bref. P>
Vous pouvez mesurer vos temps de compilation si cela semble être une vraie préoccupation. P>
Si vous pouvez obtenir une copie, Le langage de programmation C ++ (et de nombreux autres livres) ont une section détaillée sur l'organisation du code source et les avantages spécifiques de la séparation du code dans .h et .cpp. p>
Oui, c'est acceptable. De plus, si vous faites des modèles et que vous n'avez pas de compilateur avec Cependant, notez qu'il peut augmenter les dépendances et ainsi rendre la compilation plus lentement. P> Exporter code> Support, vous n'avez pas de choix. P>
Ce irait bien si vous utiliserez ce fichier d'en-tête dans vos futurs codes ou projets, et si vous souhaitez le partager avec les autres. P>
dépend de la manière dont vous liez. Pour éviter de devoir voir des messages tels que la redéfinition de bla, la définition précédente dans le fichier bla.h sur la ligne 13 vient de mettre tout sauf la déclaration dans une .CPP. P>
Cela dépend de ce que vous visez. P>
Pour un projet d'animal de compagnie, c'est acceptable, mais tout est vraiment. P>
Pour un projet réel, vous devez vous poser un certain nombre de questions: P>
Si les réponses vous satisfont, allez-y. P>
C'est principalement une question de gestion de la dépendance. En mettant la définition des méthodes dans l'en-tête, ils sont susceptibles d'être inlincé par le compilateur, ce qui signifie que chaque fois qu'ils changent, vous devrez recompiler tout ce qui dépend de cette classe. P>
Les modèles le font, cependant, les modèles ont généralement peu de dépendances (autres incluses) et vous êtes relativement obligé de procéder de la sorte (bien que vous puissiez que vous puissiez externalisé le code dépendant sans modèles pour réduire les dépendances). P>
Pour de grands grands projets où la gestion de la dépendance est avant tout, alors je conseillerais contre. Dans ces projets, un ABI stable et la capacité de promouvoir des changements compatibles binaires sont des économiseurs de vie en cas de problème et ils valent bien le "léger" inconvénient pour le développeur. P>
Dans tous les cas, veuillez ne pas définir les méthodes au milieu de la classe. Même vous pouvez les définir après la déclaration de classe. Cela facilite la lecture de personnes (vous-même quelques mois) pour obtenir une compréhension de l'interface rapidement. P>
IMO, si vos méthodes sont principalement une doublure, la définition de la méthode à l'intérieur de la classe ne distrait pas beaucoup et peut parfois augmenter la compréhensibilité du code; Et en fait, la seule raison pour laquelle quelqu'un ne voudrait pas créer un fichier distinct .CPP est parce que la classe est petite et que les méthodes sont toutes triviales.
@Lie Ryan: Je conviens que des doublures (comme vide code> /
(code> code>) peuvent être définis au milieu de la classe sans déranger une trop grande ... mais alors c'est Difficile de définir la limite entre une doublure une doublure, une doublure qui est enveloppée car elle ne correspondait pas à l'écran, à deux doublures plus courtes que la doublure enveloppée, ... Après cela, tout le monde appelle .
Mais vous n'avez pas besoin de définir une limite difficile, suivez simplement vos sentiments d'intestin. En fin de compte, le compilateur produirait toujours la même sortie ou équivalente. De nombreux guides de style de programmation favorisent un style cohérent juste parce que la cohérence est facile à quantifier, si quelque chose ressemble toujours à la même chose, c'est cohérent; Toutefois, dans de nombreux cas, cette obsession de cohérence est au coût d'ignorer les avantages potentiels difficiles à quantifier. La lisibilité et la compréhension ne sont pas aussi faciles à quantifier; Et en conséquence, obtenez souvent des lignes directrices sous tension latérales.