Sono confuso su come separare il codice di implementazione e dichiarazioni di una classe semplice in una nuova intestazione e file cpp. Ad esempio, come dovrei separare il codice per la classe seguente?Separazione del codice classe in un'intestazione e file cpp
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 protezioni di tipo #ifndef oppure, se si utilizza una piattaforma MS, è possibile utilizzare anche #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'attuazione 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;
}
Ricorda che se stai facendo la programmazione dei template, devi tenere tutto nel file .h in modo che il compilatore istanzia il codice giusto al momento della compilazione. – linello
im ottenere un errore con un simbolo duplicato im non sono sicuro di come farlo slittare .ld: simbolo duplicato A2DD :: A2DD (int, int) in ./src/rstring.o e ./src/A2DD.o per l'architettura x86_64 – drdrdr
hai la roba '# ifndef' nell'intestazione? – fritzone
Fondamentalmente una sintassi modificata della dichiarazione di funzione/definizioni:
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;
}
si lasciano 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 inserire 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;
}
Potreste mescolare i due (lasciare getSum() definizione nell'intestazione per esempio). Questo è utile poiché dà al compilatore maggiori possibilità di inlining, ad 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.
Si noti che per i modelli è necessario conservare tutto nelle intestazioni.
L'inserimento di membri e funzioni privati nel file di intestazione non viene considerato come perdita di dettagli di implementazione? – Jason
@Jason, una specie di. Questi sono * dettagli * necessari per l'implementazione. Ad esempio, devo sapere quanto spazio occuperà una classe in pila. Le implementazioni di funzioni non sono necessarie per altre unità di compilazione. –
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 delle funzioni e membri nel file di intestazione.
Ciò consentirà ad altri file di progetto di vedere come appare la classe senza dover conoscere l'implementazione.
Oltre a ciò, è possibile includere altri file di intestazione nell'implementazione anziché nell'intestazione. Questo è importante perché tutte le intestazioni incluse nel file di intestazione saranno incluse (ereditate) in qualsiasi altro file che include il file di intestazione.
Di solito si mettono solo dichiarazioni e funzioni davvero brevi inline 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_;
};
In generale il tuo .h contiene la defition di classe, ovvero tutti i tuoi dati e tutti le tue dichiarazioni di metodo.Ti piace questa 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 di metodi come questo:
A2DD.cpp:
A2DD::A2DD(int x,int y)
{
gx = x;
gy = y;
}
int A2DD::getSum()
{
return gx + gy;
}
Solo un paio di commenti: Il costruttore deve sempre utilizzare un elenco di inizializzazione invece di impostare i membri del corpo. Per una spiegazione buona e semplice, vedere: http://www.codeguru.com/forum/showthread.php?t=464084 Inoltre, almeno nella maggior parte dei luoghi, è consuetudine avere il campo pubblico in alto. Non influirà su nulla, ma dal momento che i campi pubblici sono la documentazione della tua classe, ha senso averlo in cima. – martiert
@martiert Avere 'public:' i membri in cima _could_ influenzano uno _lot_, se l'utente li sposta in base a questo consiglio - ma ha delle dipendenze di ordinamento tra i membri e non è ancora a conoscenza che i membri sono inizializzati nell'ordine della loro dichiarazione; -) –
@underscore_d che è vero. Ma poi di nuovo, stiamo compilando tutti gli avvertimenti come errori e tutti gli avvertimenti a cui possiamo pensare, giusto? Almeno questo ti dirà che stai rovinando tutto, ma si, la gente usa il modo di piccoli avvertimenti, e semplicemente li ignora :( – martiert