Separando o código de classe em um cabeçalho e arquivo cpp

Estou confuso sobre como separar código de implementação e declarações de uma classe simples em um novo cabeçalho e arquivo cpp. Por exemplo, como eu separaria o código da classe a seguir?

class A2DD
{
  private:
  int gx;
  int gy;

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

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

A declaração de classe entra no arquivo de cabeçalho. É importante adicionar os #ifndefprotetores de inclusão ou, se você estiver em uma plataforma MS, também poderá usar #pragma once. Também omiti o privado, por padrão, os membros da classe C ++ são privados.

// A2DD.h
#ifndef A2DD_H
#define A2DD_H

class A2DD
{
  int gx;
  int gy;

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

};

#endif

e a implementação está no arquivo CPP:

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

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

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

Em geral, seu .h contém a definição de classe, que é todos os seus dados e todas as suas declarações de método. Assim no seu caso:

A2DD.h:

class A2DD
{
  private:
  int gx;
  int gy;

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

E então o seu .cpp contém as implementações dos métodos como este:

A2DD.cpp:

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

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

É importante ressaltar aos leitores que se deparam com essa pergunta ao pesquisar o assunto de maneira mais ampla que o procedimento da resposta aceita não é necessário no caso de você apenas querer dividir seu projeto em arquivos. Só é necessário quando você precisa de várias implementações de classes únicas. Se sua implementação por classe for uma, basta apenas um arquivo de cabeçalho para cada uma.

Portanto, a partir do exemplo da resposta aceita, apenas esta parte é necessária:

#ifndef MYHEADER_H
#define MYHEADER_H

//Class goes here, full declaration AND implementation

#endif

As definições de pré-processador #ifndef etc. permitem que ele seja usado várias vezes.

PS. O tópico fica mais claro depois que você percebe que C / C ++ é 'idiota' e #include é apenas uma maneira de dizer "despejar este texto neste local".

Basicamente, uma sintaxe modificada da declaração / definição da função:

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

A idéia é manter todas as assinaturas de funções e membros no arquivo de cabeçalho.
Isso permitirá que outros arquivos do projeto vejam como é a classe sem precisar conhecer a implementação.

Além disso, você pode incluir outros arquivos de cabeçalho na implementação, em vez do cabeçalho. Isso é importante porque quaisquer cabeçalhos incluídos no arquivo de cabeçalho serão incluídos (herdados) em qualquer outro arquivo que inclua o arquivo de cabeçalho.

Você deixa as declarações no arquivo de cabeçalho:

class A2DD
{
  private:
  int gx;
  int gy;

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

E coloque as definições no arquivo de implementação.

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

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

Você pode misturar os dois (deixe a getSum()definição no cabeçalho, por exemplo). Isso é útil, pois fornece ao compilador uma melhor chance de incluir, por exemplo. Mas isso também significa que alterar a implementação (se deixada no cabeçalho) pode desencadear uma reconstrução de todos os outros arquivos que incluem o cabeçalho.

Observe que, para os modelos, você precisa manter tudo nos cabeçalhos.

Normalmente, você coloca apenas declarações e funções embutidas muito curtas no arquivo de cabeçalho:

Por exemplo:

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

Também não vou referir o seu exemplo, pois é bastante simples para uma resposta geral (por exemplo, não contém funções modeladas , o que força você a implementá-las no cabeçalho), o que sigo como regra geral é o pimpl idioma

Tem alguns benefícios à medida que você obtém tempos de compilação mais rápidos e o açúcar sintático:

class->member ao invés de class.member

A única desvantagem é o ponteiro extra que você paga.