Rozdzielanie kodu klasy na nagłówek i plik CPP

Nie wiem, jak oddzielić kod implementacji i deklaracji prostej klasy do nowego nagłówka i pliku CPP. Na przykład, jak oddzielić kod dla następującej klasy?

class A2DD
{
  private:
  int gx;
  int gy;

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

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

Deklaracja klasy trafia do pliku nagłówkowego. Ważne jest, aby dodać #ifndefosłony włączające, a jeśli jesteś na platformie MS, możesz również użyć #pragma once. Pominąłem również prywatne, domyślnie członkowie klasy C ++ są prywatni.

// A2DD.h
#ifndef A2DD_H
#define A2DD_H

class A2DD
{
  int gx;
  int gy;

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

};

#endif

a implementacja idzie w pliku CPP:

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

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

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

Ogólnie twój .h zawiera definicję klasy, czyli wszystkie twoje dane i wszystkie deklaracje metod. Tak jak w twoim przypadku:

A2DD.h:

class A2DD
{
  private:
  int gx;
  int gy;

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

A następnie twój .cpp zawiera implementacje metod takich jak ta:

A2DD.cpp:

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

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

Należy zwrócić uwagę czytelników, którzy natkną się na to pytanie podczas szerszego badania tematu, że procedura zaakceptowanej odpowiedzi nie jest wymagana w przypadku, gdy chcesz po prostu podzielić projekt na pliki. Jest potrzebny tylko wtedy, gdy potrzebujesz wielu implementacji pojedynczych klas. Jeśli Twoja implementacja na klasę to jedna, wystarczy jeden plik nagłówkowy dla każdej.

Stąd z przykładu przyjętej odpowiedzi potrzebna jest tylko ta część:

#ifndef MYHEADER_H
#define MYHEADER_H

//Class goes here, full declaration AND implementation

#endif

Definicje preprocesorów #ifndef itp. Pozwalają na wielokrotne ich użycie.

PS. Temat staje się jaśniejszy, gdy zdasz sobie sprawę, że C / C ++ jest „głupi”, a #include to tylko sposób na powiedzenie „zrzuć ten tekst w tym miejscu”.

Zasadniczo zmodyfikowana składnia deklaracji / definicji funkcji:

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

Pomysł polega na zachowaniu wszystkich sygnatur funkcji i elementów członkowskich w pliku nagłówkowym.
Pozwoli to innym plikom projektu zobaczyć, jak wygląda klasa, bez konieczności znajomości implementacji.

Poza tym możesz następnie dołączyć inne pliki nagłówkowe do implementacji zamiast nagłówka. Jest to ważne, ponieważ niezależnie od tego, które nagłówki są zawarte w pliku nagłówkowym, zostaną uwzględnione (odziedziczone) w każdym innym pliku zawierającym plik nagłówkowy.

Pozostawiasz deklaracje w pliku nagłówkowym:

class A2DD
{
  private:
  int gx;
  int gy;

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

I umieść definicje w pliku implementacji.

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

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

Możesz połączyć te dwa elementy (odejdź getSum() na przykład definicję w nagłówku). Jest to przydatne, ponieważ daje kompilatorowi większą szansę na przykład na wstawianie. Ale oznacza to również, że zmiana implementacji (jeśli pozostawiona w nagłówku) może spowodować przebudowę wszystkich innych plików, które zawierają nagłówek.

Zauważ, że w przypadku szablonów musisz zachować to wszystko w nagłówkach.

Zwykle umieszczasz tylko deklaracje i naprawdę krótkie funkcje wbudowane w pliku nagłówkowym:

Na przykład:

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

Nie będę odnosić się zbyt swój przykład jak to jest dość proste do ogólnej odpowiedzi (na przykład nie zawiera funkcje na matrycy, które zmuszają do ich wdrożenia w nagłówku), co śledzę jak zasada jest pimpl idiom

Ma sporo zalet, ponieważ uzyskujesz szybsze czasy kompilacji i cukier syntaktyczny:

class->member zamiast class.member

Jedyną wadą jest dodatkowy wskaźnik, który płacisz.