Separar el código de clase en un encabezado y archivo cpp

Estoy confundido sobre cómo separar el código de implementación y declaraciones de una clase simple en un nuevo encabezado y archivo cpp. Por ejemplo, ¿cómo separaría el código para la siguiente clase?

class A2DD
{
  private:
  int gx;
  int gy;

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

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

La declaración de clase va al archivo de encabezado. Es importante que agregue los #ifndefprotectores de inclusión, o si está en una plataforma MS también puede usar #pragma once. También he omitido lo privado, por defecto los miembros de la clase C ++ son privados.

// A2DD.h
#ifndef A2DD_H
#define A2DD_H

class A2DD
{
  int gx;
  int gy;

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

};

#endif

y la implementación va en el archivo CPP:

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

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

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

En general, su .h contiene la definición de clase, que son todos sus datos y todas sus declaraciones de método. Así en tu caso:

A2DD.h:

class A2DD
{
  private:
  int gx;
  int gy;

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

Y luego, su .cpp contiene las implementaciones de los siguientes métodos:

A2DD.cpp:

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

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

Es importante señalar a los lectores que se encuentran con esta pregunta cuando investigan el tema de manera más amplia que el procedimiento de respuesta aceptado no es necesario en el caso de que solo quieran dividir su proyecto en archivos. Solo es necesario cuando necesita múltiples implementaciones de clases individuales. Si su implementación por clase es una, solo un archivo de encabezado para cada uno es suficiente.

Por lo tanto, del ejemplo de la respuesta aceptada solo se necesita esta parte:

#ifndef MYHEADER_H
#define MYHEADER_H

//Class goes here, full declaration AND implementation

#endif

Las definiciones de preprocesador #ifndef etc. permiten que se use varias veces.

PD. El tema se vuelve más claro una vez que te das cuenta de que C / C ++ es 'tonto' y #include es simplemente una forma de decir "volcar este texto en este lugar".

Básicamente una sintaxis modificada de declaración / definiciones de función:

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

La idea es mantener todas las firmas de funciones y miembros en el archivo de encabezado.
Esto permitirá que otros archivos del proyecto vean cómo se ve la clase sin tener que conocer la implementación.

Y además de eso, puede incluir otros archivos de encabezado en la implementación en lugar del encabezado. Esto es importante porque los encabezados incluidos en su archivo de encabezado se incluirán (heredarán) en cualquier otro archivo que incluya su archivo de encabezado.

Dejas las declaraciones en el archivo de encabezado:

class A2DD
{
  private:
  int gx;
  int gy;

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

Y poner las definiciones en el archivo de implementación.

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

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

Puede mezclar los dos (deje la getSum()definición en el encabezado, por ejemplo). Esto es útil ya que le da al compilador una mejor oportunidad de alinearse, por ejemplo. Pero también significa que cambiar la implementación (si se deja en el encabezado) podría desencadenar una reconstrucción de todos los demás archivos que incluyen el encabezado.

Tenga en cuenta que para las plantillas, debe mantenerlo todo en los encabezados.

Por lo general, solo coloca declaraciones y funciones en línea realmente cortas en el archivo de encabezado:

Por ejemplo:

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

No voy a referirme también a su ejemplo, ya que es bastante simple para una respuesta general (por ejemplo, no contiene funciones con plantilla, que lo obligan a implementarlas en el encabezado), lo que sigo como regla general es el pimpl idioma

Tiene bastantes beneficios ya que obtienes tiempos de compilación más rápidos y el azúcar sintáctico:

class->member en vez de class.member

El único inconveniente es el puntero adicional que paga.