Come leggere:
Questo articolo è piuttosto lungo Se vuoi conoscere sia gli aggregati che i POD (Plain Old Data), prenditi del tempo e leggilo. Se sei interessato solo agli aggregati, leggi solo la prima parte. Se si è interessati solo in POD allora è necessario prima leggere la definizione, implicazioni, ed esempi di aggregati e poi si può passare al POD, ma io consiglierei comunque leggere la prima parte nella sua interezza. La nozione di aggregati è essenziale per la definizione dei POD. Se trovi errori (anche minori, inclusi grammatica, stile, formattazione, sintassi, ecc.), Lascia un commento, lo modificherò.
Questa risposta si applica a C ++ 03. Per altri standard C ++ vedere:
Cosa sono gli aggregati e perché sono speciali
Definizione formale dallo standard C ++ ( C ++ 03 8.5.1 §1 ) :
Un aggregato è un array o una classe (clausola 9) senza costruttori dichiarati dall'utente (12.1), senza membri di dati non statici privati o protetti (clausola 11), senza classi di base (clausola 10) e senza funzioni virtuali (10.3 ).
Quindi, OK, analizziamo questa definizione. Prima di tutto, qualsiasi array è un aggregato. Una classe può anche essere un aggregato se ... aspetta! non si dice nulla su strutture o sindacati, non possono essere aggregati? Si Loro possono. In C ++, il termine si classriferisce a tutte le classi, strutture e sindacati. Quindi, una classe (o struttura o unione) è un aggregato se e solo se soddisfa i criteri delle definizioni precedenti. Cosa implicano questi criteri?
Ciò non significa che una classe aggregata non possa avere costruttori, in realtà può avere un costruttore predefinito e / o un costruttore di copie purché siano implicitamente dichiarati dal compilatore e non esplicitamente dall'utente
Nessun membro di dati non statici privato o protetto . Puoi avere tutte le funzioni membro private e protette (ma non i costruttori), nonché quanti membri dati statici privati o protetti e funzioni membro desideri e non violare le regole per le classi aggregate
Una classe aggregata può avere un operatore e / o un distruttore di copia-assegnazione dichiarati dall'utente / definiti dall'utente
Un array è un aggregato anche se è un array di tipo di classe non aggregato.
Ora diamo un'occhiata ad alcuni esempi:
class NotAggregate1
{
virtual void f() {} //remember? no virtual functions
};
class NotAggregate2
{
int x; //x is private by default and non-static
};
class NotAggregate3
{
public:
NotAggregate3(int) {} //oops, user-defined constructor
};
class Aggregate1
{
public:
NotAggregate1 member1; //ok, public member
Aggregate1& operator=(Aggregate1 const & rhs) {/* */} //ok, copy-assignment
private:
void f() {} // ok, just a private function
};
Ti viene l'idea. Ora vediamo come gli aggregati sono speciali. A differenza delle classi non aggregate, possono essere inizializzate con parentesi graffe {}. Questa sintassi di inizializzazione è comunemente nota per le matrici e abbiamo appena appreso che si tratta di aggregati. Quindi, cominciamo con loro.
Type array_name[n] = {a1, a2, …, am};
if (m == n)
l'i esimo elemento della matrice viene inizializzato con i
else if (m <n)
i primi m elementi dell'array vengono inizializzati con un 1 , un 2 , ..., a m e gli altrin - melementi sono, se possibile, inizializzati dal valore (vedi sotto per la spiegazione del termine)
altrimenti se (m> n)
il compilatore genererà un
altro errore (questo è il caso in cui n non è specificato affatto int a[] = {1, 2, 3};)
la dimensione di si presume che l'array (n) sia uguale a m, quindiint a[] = {1, 2, 3};è equivalente aint a[3] = {1, 2, 3};
Quando un oggetto di tipo scalare ( bool, int, char, double, puntatori, ecc) è valore inizializzato significa viene inizializzato con 0per quel tipo ( falseper bool, 0.0per double, ecc). Quando un oggetto di tipo classe con un costruttore predefinito dichiarato dall'utente viene inizializzato con valore, viene chiamato il suo costruttore predefinito. Se il costruttore predefinito viene definito implicitamente, tutti i membri non statici vengono inizializzati in modo ricorsivo. Questa definizione è imprecisa e un po 'errata, ma dovrebbe darti l'idea di base. Un riferimento non può essere inizializzato dal valore. L'inizializzazione del valore per una classe non aggregata può non riuscire se, ad esempio, la classe non ha un costruttore predefinito appropriato.
Esempi di inizializzazione di array:
class A
{
public:
A(int) {} //no default constructor
};
class B
{
public:
B() {} //default constructor available
};
int main()
{
A a1[3] = {A(2), A(1), A(14)}; //OK n == m
A a2[3] = {A(2)}; //ERROR A has no default constructor. Unable to value-initialize a2[1] and a2[2]
B b1[3] = {B()}; //OK b1[1] and b1[2] are value initialized, in this case with the default-ctor
int Array1[1000] = {0}; //All elements are initialized with 0;
int Array2[1000] = {1}; //Attention: only the first element is 1, the rest are 0;
bool Array3[1000] = {}; //the braces can be empty too. All elements initialized with false
int Array4[1000]; //no initializer. This is different from an empty {} initializer in that
//the elements in this case are not value-initialized, but have indeterminate values
//(unless, of course, Array4 is a global array)
int array[2] = {1, 2, 3, 4}; //ERROR, too many initializers
}
Ora vediamo come le classi aggregate possono essere inizializzate con le parentesi graffe. Praticamente allo stesso modo. Invece degli elementi dell'array, inizializzeremo i membri di dati non statici nell'ordine del loro aspetto nella definizione della classe (sono tutti pubblici per definizione). Se ci sono meno inizializzatori rispetto ai membri, il resto viene inizializzato dal valore. Se è impossibile inizializzare il valore di uno dei membri che non sono stati inizializzati esplicitamente, viene visualizzato un errore di compilazione. Se sono presenti più inizializzatori del necessario, viene visualizzato anche un errore di compilazione.
struct X
{
int i1;
int i2;
};
struct Y
{
char c;
X x;
int i[2];
float f;
protected:
static double d;
private:
void g(){}
};
Y y = {'a', {10, 20}, {20, 30}};
Nell'esempio sopra y.cè inizializzato con 'a', y.x.i1con 10, y.x.i2con 20, y.i[0]con 20, y.i[1]con 30ed y.fè inizializzato valore, ovvero inizializzato con 0.0. Il membro statico protetto dnon è affatto inizializzato, perché lo è static.
I sindacati aggregati sono diversi in quanto è possibile inizializzare solo il loro primo membro con parentesi graffe. Penso che se sei abbastanza avanzato in C ++ per prendere in considerazione l'uso dei sindacati (il loro uso può essere molto pericoloso e deve essere considerato attentamente), potresti cercare tu stesso le regole per i sindacati :).
Ora che sappiamo cosa c'è di speciale negli aggregati, proviamo a capire le restrizioni sulle classi; cioè, perché sono lì. Dovremmo capire che l'inizializzazione a livello di membro con parentesi graffe implica che la classe non è altro che la somma dei suoi membri. Se è presente un costruttore definito dall'utente, significa che l'utente deve fare un lavoro extra per inizializzare i membri, pertanto l'inizializzazione del controvento sarebbe errata. Se sono presenti funzioni virtuali, significa che gli oggetti di questa classe hanno (sulla maggior parte delle implementazioni) un puntatore alla cosiddetta vtable della classe, che è impostata nel costruttore, quindi l'inizializzazione del controvento sarebbe insufficiente. Potresti capire il resto delle restrizioni in modo simile a un esercizio :).
Quindi abbastanza sugli aggregati. Ora possiamo definire un insieme più rigoroso di tipi, vale a dire, POD
Cosa sono i POD e perché sono speciali
Definizione formale dallo standard C ++ ( C ++ 03 9 §4 ) :
Una POD-struct è una classe aggregata che non ha membri di dati non statici di tipo non-POD-struct, non-POD-union (o array di tali tipi) o riferimenti, e non ha un operatore di assegnazione della copia definito dall'utente e nessun distruttore definito dall'utente. Allo stesso modo, un'unione POD è un'unione aggregata che non ha membri di dati non statici di tipo non-POD-struct, non-POD-union (o array di tali tipi) o riferimento e non ha un operatore di assegnazione della copia definito dall'utente e nessun distruttore definito dall'utente. Una classe POD è una classe che è una struttura POD o un'unione POD.
Wow, questo è più difficile da analizzare, no? :) Lasciamo fuori i sindacati (per gli stessi motivi di cui sopra) e riformuliamo in modo un po 'più chiaro:
Una classe aggregata viene chiamata POD se non ha un operatore e distruttore di assegnazione copia definiti dall'utente e nessuno dei suoi membri non statici è una classe non POD, un array di non POD o un riferimento.
Cosa implica questa definizione? (Ho già detto che POD sta per Plain Old Data ?)
- Tutte le classi POD sono aggregati o, per dirla al contrario, se una classe non è un aggregato, non è sicuro che sia un POD
- Le classi, proprio come le strutture, possono essere POD anche se il termine standard è POD-struct per entrambi i casi
- Proprio come nel caso degli aggregati, non importa quali membri statici abbiano la classe
Esempi:
struct POD
{
int x;
char y;
void f() {} //no harm if there's a function
static std::vector<char> v; //static members do not matter
};
struct AggregateButNotPOD1
{
int x;
~AggregateButNotPOD1() {} //user-defined destructor
};
struct AggregateButNotPOD2
{
AggregateButNotPOD1 arrOfNonPod[3]; //array of non-POD class
};
Le classi POD, i sindacati POD, i tipi scalari e le matrici di tali tipi sono collettivamente chiamati tipi POD.
I POD sono speciali in molti modi. Fornirò solo alcuni esempi.
Le classi POD sono le più vicine alle strutture C. A differenza di loro, i POD possono avere funzioni membro e membri statici arbitrari, ma nessuno di questi due modifica il layout di memoria dell'oggetto. Quindi, se si desidera scrivere una libreria dinamica più o meno portatile che può essere utilizzata da C e persino .NET, si dovrebbe provare a fare in modo che tutte le funzioni esportate prendano e restituiscano solo parametri di tipo POD.
La durata degli oggetti di tipo di classe non POD inizia al termine del costruttore e termina al termine del distruttore. Per le classi POD, la durata inizia quando la memoria per l'oggetto è occupata e termina quando la memoria viene rilasciata o riutilizzata.
Per gli oggetti di tipo POD è garantito dallo standard che quando memcpyil contenuto dell'oggetto viene inserito in un array di caratteri char o unsigned char, e quindi memcpyil contenuto torna nell'oggetto, l'oggetto mantiene il suo valore originale. Si noti che non esiste tale garanzia per oggetti di tipo non POD. Inoltre, puoi tranquillamente copiare oggetti POD con memcpy. L'esempio seguente presuppone che T sia un tipo POD:
#define N sizeof(T)
char buf[N];
T obj; // obj initialized to its original value
memcpy(buf, &obj, N); // between these two calls to memcpy,
// obj might be modified
memcpy(&obj, buf, N); // at this point, each subobject of obj of scalar type
// holds its original value
vai alla dichiarazione. Come forse saprai, è illegale (il compilatore dovrebbe generare un errore) fare un salto tramite goto da un punto in cui alcune variabili non erano ancora nell'ambito fino a un punto in cui è già nell'ambito. Questa restrizione si applica solo se la variabile è di tipo non POD. Nel seguente esempio f()è mal formato mentre g()è ben formato. Si noti che il compilatore di Microsoft è troppo liberale con questa regola: emette solo un avviso in entrambi i casi.
int f()
{
struct NonPOD {NonPOD() {}};
goto label;
NonPOD x;
label:
return 0;
}
int g()
{
struct POD {int i; char c;};
goto label;
POD x;
label:
return 0;
}
È garantito che non ci sarà imbottitura all'inizio di un oggetto POD. In altre parole, se il primo membro di una classe POD A è di tipo T, puoi tranquillamente andare reinterpret_castda e ottenere il puntatore al primo membro e viceversa.A*T*
La lista potrebbe continuare all'infinito…
Conclusione
È importante capire cosa sia esattamente un POD perché molte funzionalità del linguaggio, come vedi, si comportano diversamente per loro.