Quelle est la différence entre un fichier .cpp et un fichier .h?
Parce que j'ai créé des fichiers .cpp puis que je les ai transférés dans des fichiers .h, la seule différence que je peux trouver est que vous ne pouvez pas inclure de fichiers .cpp. Y a-t-il une différence qui me manque?
Le système de compilation C++ (compilateur) ne connaît pas de différence, c'est donc une convention.
La convention est que les fichiers .h sont des déclarations et les fichiers .cpp sont des définitions.
C'est pourquoi les fichiers .h sont #included - nous incluons les déclarations.
Le fichier .cpp est l'unité de compilation: c'est le véritable fichier de code source qui sera compilé (en C++).
Les fichiers .h (en-tête) sont des fichiers qui seront virtuellement copiés/collés dans les fichiers .cpp où l'instruction de précompilateur #include apparaît. Une fois le code d'en-tête inséré dans le code .cpp, la compilation du fichier .cpp peut commencer.
Je connais la différence entre une déclaration et une définition.
Tandis que:
- Un fichier CPP comprend les définitions de tout en-tête qu'il contient (car le fichier CPP et le fichier d'en-tête deviennent ensemble une "unité de traduction").
- Un fichier d’en-tête peut être inclus dans plusieurs fichiers CPP.
- L'éditeur de liens n'appréciera généralement rien de ce qui est défini dans plusieurs fichiers CPP.
Par conséquent, toute définition dans un fichier d'en-tête doit être en ligne ou statique. Les fichiers d’en-tête contiennent également des déclarations utilisées par plusieurs fichiers CPP.
Les définitions qui ne sont ni statiques ni incorporées sont placées dans des fichiers CPP. De plus, toutes les déclarations qui ne sont nécessaires que dans un fichier CPP sont souvent placées dans ce fichier CPP lui-même, et non dans un fichier d'en-tête (partageable).
Les fichiers .h, ou fichiers d'en-tête, sont utilisés pour répertorier les variables d'instance et les méthodes accessibles au public dans la déclaration de classe. Les fichiers .cpp, ou fichiers d'implémentation, sont utilisés pour implémenter réellement ces méthodes et utiliser ces variables d'instance.
La raison pour laquelle ils sont séparés est que les fichiers .h ne sont pas compilés en code binaire, contrairement aux fichiers .cpp. Prenez une bibliothèque, par exemple. Dites que vous êtes l'auteur et que vous ne voulez pas que ce soit open source. Vous distribuez donc la bibliothèque binaire compilée et les fichiers d’en-tête à vos clients. Cela leur permet de voir facilement toutes les informations sur les classes de votre bibliothèque qu’elles peuvent utiliser sans savoir comment vous avez implémenté ces méthodes. Ils sont plus destinés aux personnes utilisant votre code plutôt qu'au compilateur. Comme cela a été dit auparavant: c'est la convention.
Un fichier d’en-tête (.h, .hpp, ...) contient
- Définitions de classe (
class X { ... };) - Définitions de fonctions en ligne (
inline int get_cpus() { ... }) - Déclarations de fonction (
void help();) - Déclarations d'objet (
extern int debug_enabled;)
Un fichier source (.c, .cpp, .cxx) contient
- Définitions de fonctions (
void help() { ... }ouvoid X::f() { ... }) - Définitions d'objet (
int debug_enabled = 1;)
Toutefois, la convention selon laquelle les en-têtes sont nommés avec un suffixe .h et les fichiers source nommés avec un suffixe .cpp n'est pas vraiment requise. On peut toujours dire à un bon compilateur comment traiter un fichier, quel que soit son suffixe de nom de fichier (-x <file-type> pour gcc. Like -x c++).
Les fichiers source contiendront des définitions qui ne doivent être présentes qu'une seule fois dans tout le programme. Donc, si vous incluez un fichier source quelque part et que vous liez ensuite le résultat de la compilation de ce fichier, puis celui du fichier source lui-même, vous obtiendrez bien sûr des erreurs de l'éditeur de liens, car ces définitions apparaissent maintenant deux fois: fichier source inclus, puis dans le fichier qui l’a inclus. C'est pourquoi vous avez eu des problèmes pour inclure le fichier .cpp.
Une bonne règle est "les fichiers .h devraient avoir des déclarations [potentiellement] utilisées par plusieurs fichiers source, mais aucun code ne sera exécuté."
D'autres ont déjà fourni de bonnes explications, mais j'ai pensé clarifier les différences entre les différentes extensions:
Fichiers sources pour C: .c Fichiers d'en-tête pour C: .h Fichiers sources pour C++: .cpp Fichiers d'en-tête pour C++: .hpp
Bien sûr, comme cela a déjà été souligné, ce ne sont que des conventions. En fait, le compilateur n'y prête pas attention - c'est simplement pour le bénéfice du codeur.
Par convention, les fichiers .h sont inclus dans d'autres fichiers et ne sont jamais compilés directement par eux-mêmes. Les fichiers .cpp sont - là encore, par convention - les racines du processus de compilation; ils incluent les fichiers .h directement ou indirectement, mais généralement pas les fichiers .cpp.