Trennen des Klassencodes in eine Header- und eine CPP-Datei

Ich bin verwirrt darüber, wie Implementierungs- und Deklarationscode einer einfachen Klasse in eine neue Header- und CPP-Datei getrennt werden kann. Wie würde ich beispielsweise den Code für die folgende Klasse trennen?

class A2DD
{
  private:
  int gx;
  int gy;

  public:
  A2DD(int x,int y)
  {
    gx = x;
    gy = y;
  }

  int getSum()
  {
    return gx + gy;
  }
};

Die Klassendeklaration geht in die Header-Datei. Es ist wichtig, dass Sie die #ifndefInclude-Schutzvorrichtungen hinzufügen. Wenn Sie sich auf einer MS-Plattform befinden, können Sie diese auch verwenden #pragma once. Außerdem habe ich das private weggelassen, standardmäßig sind C ++ - Klassenmitglieder privat.

// A2DD.h
#ifndef A2DD_H
#define A2DD_H

class A2DD
{
  int gx;
  int gy;

public:
  A2DD(int x,int y);
  int getSum();

};

#endif

und die Implementierung geht in die CPP-Datei:

// A2DD.cpp
#include "A2DD.h"

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

int A2DD::getSum()
{
  return gx + gy;
}

Im Allgemeinen enthält Ihre .h die Klassendefinition, die alle Ihre Daten und alle Ihre Methodendeklarationen enthält. So in Ihrem Fall:

A2DD.h:

class A2DD
{
  private:
  int gx;
  int gy;

  public:
  A2DD(int x,int y);    
  int getSum();
};

Und dann enthält Ihre .cpp die Implementierungen der folgenden Methoden:

A2DD.cpp:

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

int A2DD::getSum()
{
  return gx + gy;
}

Es ist wichtig, die Leser, die über diese Frage stolpern, darauf hinzuweisen, dass das Verfahren der akzeptierten Antwort nicht erforderlich ist, wenn Sie Ihr Projekt nur in Dateien aufteilen möchten. Es wird nur benötigt, wenn Sie mehrere Implementierungen einzelner Klassen benötigen. Wenn Ihre Implementierung pro Klasse eine ist, reicht nur eine Header-Datei für jede aus.

Aus dem Beispiel der akzeptierten Antwort wird daher nur dieser Teil benötigt:

#ifndef MYHEADER_H
#define MYHEADER_H

//Class goes here, full declaration AND implementation

#endif

Die Präprozessordefinitionen #ifndef usw. ermöglichen die mehrfache Verwendung.

PS. Das Thema wird klarer, sobald Sie feststellen, dass C / C ++ 'dumm' ist und #include nur eine Möglichkeit ist, "diesen Text an dieser Stelle ausgeben" zu sagen.

Grundsätzlich eine modifizierte Syntax der Funktionsdeklaration / -definitionen:

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;
  }

Die Idee ist, alle Funktionssignaturen und Mitglieder in der Header-Datei zu behalten.
Auf diese Weise können andere Projektdateien sehen, wie die Klasse aussieht, ohne die Implementierung kennen zu müssen.

Außerdem können Sie anstelle des Headers andere Header-Dateien in die Implementierung aufnehmen. Dies ist wichtig, da alle in Ihrer Header-Datei enthaltenen Header in jeder anderen Datei, die Ihre Header-Datei enthält, enthalten (geerbt) werden.

Sie belassen die Deklarationen in der Header-Datei:

class A2DD
{
  private:
  int gx;
  int gy;

  public:
    A2DD(int x,int y); // leave the declarations here
    int getSum();
};

Und fügen Sie die Definitionen in die Implementierungsdatei ein.

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

int A2DD::getSum()
{
  return gx + gy;
}

Sie können die beiden mischen (lassen Sie die getSum()Definition beispielsweise in der Kopfzeile). Dies ist nützlich, da der Compiler beispielsweise eine bessere Chance zum Inlining hat. Dies bedeutet jedoch auch, dass das Ändern der Implementierung (falls im Header belassen) eine Neuerstellung aller anderen Dateien auslösen kann, die den Header enthalten.

Beachten Sie, dass Sie für Vorlagen alles in den Kopfzeilen behalten müssen.

Normalerweise fügen Sie nur Deklarationen und wirklich kurze Inline-Funktionen in die Header-Datei ein:

Zum Beispiel:

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_;
 };

Ich werde nicht zu sehr auf Ihr Beispiel verweisen, da es für eine allgemeine Antwort recht einfach ist (zum Beispiel enthält es keine Vorlagenfunktionen, die Sie zwingen, sie in der Kopfzeile zu implementieren). Als Faustregel befolge ich den Pickel Idiom

Es hat einige Vorteile, da Sie schnellere Kompilierungszeiten und den syntaktischen Zucker erhalten:

class->member anstatt class.member

Der einzige Nachteil ist der zusätzliche Zeiger, den Sie bezahlen.