Séparation du code de classe en un en-tête et un fichier cpp

Je ne sais pas comment séparer le code d'implémentation et de déclaration d'une classe simple en un nouvel en-tête et un fichier cpp. Par exemple, comment séparer le code de 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 #ifndefgardes d'inclusion, ou si vous êtes sur une plate-forme MS, vous pouvez également les 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 classe, qui est 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;
}

Il est important de signaler aux lecteurs qui tombent sur cette question lors de la recherche sur le sujet d'une manière plus large que la procédure de réponse acceptée n'est pas nécessaire 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, un seul fichier d'en-tête pour chacune suffit.

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 'stupide' et que #include est simplement une façon de dire "vider ce texte à cet endroit".

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

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 conserver toutes les signatures de fonction et tous 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.

Et en plus de cela, vous pouvez ensuite 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 qui sont inclus dans votre fichier d'en-tête seront inclus (hérités) dans tout autre fichier qui inclut 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 (laisser la getSum()définition dans l'en-tête par exemple). Ceci est utile car cela donne au compilateur une meilleure chance d'inlining par exemple. Mais cela signifie également que la modification de l'implémentation (si elle est laissée dans l'en-tête) pourrait déclencher une reconstruction de tous les autres fichiers qui incluent 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 en ligne 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_;
 };

Je ne ferai pas trop référence à votre exemple car il est assez simple pour une réponse générale (par exemple, il ne contient pas de fonctions modèles, ce qui vous oblige à les implémenter sur l'en-tête), ce que je suis en règle générale est le bouton idiome

Cela présente de nombreux avantages car vous obtenez des temps de compilation plus rapides et le sucre syntaxique:

class->member au lieu de class.member

Le seul inconvénient est le pointeur supplémentaire que vous payez.