Séparer le code de classe en un en-tête et un fichier cpp

Je ne comprends pas comment séparer le code d’implémentation et de déclaration d’une classe simple en un nouveau fichier d’en-tête et de fichier cpp. Par exemple, comment séparer le code pour la classe suivante?

class A2DD { private: int gx; int gy; public: A2DD(int x,int y) { gx = x; gy = y; } int getSum() { return gx + gy; } }; 

La déclaration de classe va dans le fichier d’en-tête. Il est important que vous ajoutiez les gardes #ifndef , ou si vous êtes sur une plate-forme MS, vous pouvez également utiliser #pragma once . J’ai également omis le privé, par défaut les membres de la classe C ++ sont privés.

 // A2DD.h #ifndef A2DD_H #define A2DD_H class A2DD { int gx; int gy; public: A2DD(int x,int y); int getSum(); }; #endif 

et la mise en œuvre va dans le fichier CPP:

 // A2DD.cpp #include "A2DD.h" A2DD::A2DD(int x,int y) { gx = x; gy = y; } int A2DD::getSum() { return gx + gy; } 

En général, votre .h contient la définition de la classe, qui correspond à toutes vos données et à toutes vos déclarations de méthode. Comme ça dans votre cas:

 A2DD.h: class A2DD { private: int gx; int gy; public: A2DD(int x,int y); int getSum(); }; 

Et puis votre .cpp contient les implémentations des méthodes comme ceci:

 A2DD.cpp: A2DD::A2DD(int x,int y) { gx = x; gy = y; } int A2DD::getSum() { return gx + gy; } 

Fondamentalement, une syntaxe modifiée de déclaration de fonction / définitions:

a2dd.h

 class A2DD { private: int gx; int gy; public: A2DD(int x,int y); int getSum(); }; 

a2dd.cpp

 A2DD::A2DD(int x,int y) { gx = x; gy = y; } int A2DD::getSum() { return gx + gy; } 

A2DD.h

 class A2DD { private: int gx; int gy; public: A2DD(int x,int y); int getSum(); }; 

A2DD.cpp

  A2DD::A2DD(int x,int y) { gx = x; gy = y; } int A2DD::getSum() { return gx + gy; } 

L’idée est de garder toutes les signatures de fonction et les membres dans le fichier d’en-tête.
Cela permettra aux autres fichiers de projet de voir à quoi ressemble la classe sans avoir à connaître l’implémentation.

De plus, vous pouvez inclure d’autres fichiers d’en-tête dans l’implémentation au lieu de l’en-tête. Ceci est important car les en-têtes inclus dans votre fichier d’en-tête seront inclus (hérités) dans tout autre fichier incluant votre fichier d’en-tête.

Vous laissez les déclarations dans le fichier d’en-tête:

 class A2DD { private: int gx; int gy; public: A2DD(int x,int y); // leave the declarations here int getSum(); }; 

Et mettez les définitions dans le fichier d’implémentation.

 A2DD::A2DD(int x,int y) // prefix the definitions with the class name { gx = x; gy = y; } int A2DD::getSum() { return gx + gy; } 

Vous pouvez mélanger les deux (laissez la définition de getSum() dans l’en-tête par exemple). Ceci est utile car cela donne au compilateur une meilleure chance d’inclure par exemple. Mais cela signifie également que la modification de l’implémentation (si elle rest dans l’en-tête) pourrait déclencher une reconstruction de tous les autres fichiers incluant l’en-tête.

Notez que pour les modèles, vous devez tout conserver dans les en-têtes.

Habituellement, vous ne mettez que des déclarations et des fonctions inline très courtes dans le fichier d’en-tête:

Par exemple:

 class A { public: A(); // only declaration in the .h unless only a short initialization list is used. inline int GetA() const { return a_; } void DoSomethingCoplex(); // only declaration private: int a_; }; 

Il est important de faire remarquer aux lecteurs qui tombent sur cette question lorsqu’ils recherchent le sujet de manière plus large que la procédure de réponse acceptée n’est pas requirejse dans le cas où vous souhaitez simplement diviser votre projet en fichiers. Il n’est nécessaire que lorsque vous avez besoin de plusieurs implémentations de classes uniques. Si votre implémentation par classe est une, il suffit d’un fichier d’en-tête pour chacune.

Par conséquent, à partir de l’exemple de la réponse acceptée, seule cette partie est nécessaire:

 #ifndef MYHEADER_H #define MYHEADER_H //Class goes here, full declaration AND implementation #endif 

Les définitions de préprocesseur #ifndef etc. lui permettent d’être utilisé plusieurs fois.

PS Le sujet devient plus clair une fois que vous vous rendez compte que C / C ++ est “muet” et que #include est simplement une manière de dire “vider ce texte à cet endroit”.