Separare il codice di classe in un file header e cpp

Sono confuso su come separare il codice di implementazione e dichiarazioni di una classe semplice in un nuovo file di intestazione e cpp. Ad esempio, come separerei il codice per la seguente classe?

class A2DD
{
  private:
  int gx;
  int gy;

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

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

La dichiarazione di classe va nel file di intestazione. È importante aggiungere le #ifndefprotezioni di inclusione o, se ci si trova su una piattaforma MS, è anche possibile utilizzare #pragma once. Inoltre ho omesso il privato, per impostazione predefinita i membri della classe C ++ sono privati.

// A2DD.h
#ifndef A2DD_H
#define A2DD_H

class A2DD
{
  int gx;
  int gy;

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

};

#endif

e l'implementazione va nel file CPP:

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

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

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

In generale, il tuo .h contiene la classe defition, che è tutti i tuoi dati e tutte le dichiarazioni del tuo metodo. In questo modo nel tuo caso:

A2DD.h:

class A2DD
{
  private:
  int gx;
  int gy;

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

E poi il tuo .cpp contiene le implementazioni dei metodi come questo:

A2DD.cpp:

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

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

È importante sottolineare ai lettori che si imbattono in questa domanda quando ricercano l'argomento in modo più ampio che la procedura della risposta accettata non è richiesta nel caso in cui si desideri solo dividere il progetto in file. È necessario solo quando sono necessarie più implementazioni di singole classi. Se l'implementazione per classe è una, è sufficiente un solo file di intestazione per ciascuna.

Quindi, dall'esempio della risposta accettata è necessaria solo questa parte:

#ifndef MYHEADER_H
#define MYHEADER_H

//Class goes here, full declaration AND implementation

#endif

Le definizioni del preprocessore #ifndef ecc. Consentono di utilizzarlo più volte.

PS. L'argomento diventa più chiaro quando ti rendi conto che C / C ++ è 'stupido' e #include è semplicemente un modo per dire "scarica questo testo in questo punto".

Fondamentalmente una sintassi modificata della dichiarazione / definizioni delle funzioni:

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'idea è di mantenere tutte le firme e i membri delle funzioni nel file di intestazione.
Ciò consentirà ad altri file di progetto di vedere come appare la classe senza dover conoscere l'implementazione.

Inoltre, è possibile includere altri file di intestazione nell'implementazione anziché nell'intestazione. Questo è importante perché le intestazioni incluse nel file di intestazione verranno incluse (ereditate) in qualsiasi altro file che include il file di intestazione.

Lasciare le dichiarazioni nel file di intestazione:

class A2DD
{
  private:
  int gx;
  int gy;

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

E inserisci le definizioni nel file di implementazione.

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

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

È possibile mescolare i due (ad esempio, lasciare la getSum()definizione nell'intestazione). Ciò è utile poiché offre al compilatore una migliore possibilità di inline per esempio. Ma significa anche che la modifica dell'implementazione (se lasciata nell'intestazione) potrebbe innescare una ricostruzione di tutti gli altri file che includono l'intestazione.

Tieni presente che per i modelli devi tenere tutto nelle intestazioni.

Di solito metti solo dichiarazioni e funzioni inline davvero brevi nel file di intestazione:

Per esempio:

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

Non farò troppo riferimento al tuo esempio in quanto è abbastanza semplice per una risposta generale (ad esempio non contiene funzioni basate su modelli, che ti costringono a implementarli nell'intestazione), quello che seguo come regola empirica è il pimpl idioma

Ha alcuni vantaggi man mano che ottieni tempi di compilazione più rapidi e lo zucchero sintattico:

class->member invece di class.member

L'unico inconveniente è il puntatore extra che paghi.