Wie man liest:
Dieser Artikel ist ziemlich lang. Wenn Sie sowohl über Aggregate als auch über PODs (Plain Old Data) Bescheid wissen möchten, nehmen Sie sich Zeit und lesen Sie diese. Wenn Sie nur an Aggregaten interessiert sind, lesen Sie nur den ersten Teil. Wenn Sie nur in PODs interessiert sind , dann müssen Sie zunächst die Definition, Auswirkungen lesen, und Beispiele für Aggregate und dann Sie können zu PODs springen , aber ich würde noch empfehlen , den ersten Teil in seiner Gesamtheit zu lesen. Der Begriff der Aggregate ist für die Definition von PODs von wesentlicher Bedeutung. Wenn Sie Fehler finden (auch kleinere, einschließlich Grammatik, Stilistik, Formatierung, Syntax usw.), hinterlassen Sie bitte einen Kommentar, den ich bearbeiten werde.
Diese Antwort gilt für C ++ 03. Weitere C ++ - Standards finden Sie unter:
Was sind Aggregate und warum sind sie besonders?
Formale Definition aus dem C ++ - Standard ( C ++ 03 8.5.1 §1 ) :
Ein Aggregat ist ein Array oder eine Klasse (Klausel 9) ohne vom Benutzer deklarierte Konstruktoren (12.1), ohne private oder geschützte nicht statische Datenelemente (Klausel 11), ohne Basisklassen (Klausel 10) und ohne virtuelle Funktionen (10.3) ).
Also, OK, lassen Sie uns diese Definition analysieren. Zuallererst ist jedes Array ein Aggregat. Eine Klasse kann auch ein Aggregat sein, wenn… warten! Über Strukturen oder Gewerkschaften wird nichts gesagt, können sie keine Aggregate sein? Ja, sie können. In C ++ classbezieht sich der Begriff auf alle Klassen, Strukturen und Gewerkschaften. Eine Klasse (oder Struktur oder Vereinigung) ist also genau dann ein Aggregat, wenn sie die Kriterien aus den obigen Definitionen erfüllt. Was bedeuten diese Kriterien?
Dies bedeutet nicht, dass eine Aggregatklasse keine Konstruktoren haben kann. Tatsächlich kann sie einen Standardkonstruktor und / oder einen Kopierkonstruktor haben, solange sie implizit vom Compiler und nicht explizit vom Benutzer deklariert werden
Keine privaten oder geschützten nicht statischen Datenelemente . Sie können so viele private und geschützte Elementfunktionen (aber keine Konstruktoren) sowie so viele private oder geschützte statische Datenelemente und Elementfunktionen haben, wie Sie möchten, und die Regeln für Aggregatklassen nicht verletzen
Eine Aggregatklasse kann einen benutzerdefinierten / benutzerdefinierten Kopierzuweisungsoperator und / oder Destruktor haben
Ein Array ist ein Aggregat, auch wenn es sich um ein Array vom nicht aggregierten Klassentyp handelt.
Schauen wir uns nun einige Beispiele an:
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
};
Du hast die Idee. Nun wollen wir sehen, wie speziell Aggregate sind. Sie können im Gegensatz zu nicht aggregierten Klassen mit geschweiften Klammern initialisiert werden {}. Diese Initialisierungssyntax ist allgemein für Arrays bekannt, und wir haben gerade erfahren, dass es sich um Aggregate handelt. Fangen wir also mit ihnen an.
Type array_name[n] = {a1, a2, …, am};
wenn (m == n)
das i- te Element des Arrays mit einem i initialisiert wird,
wenn (m <n)
die ersten m Elemente des Arrays mit einer 1 , einer 2 , ..., einem m und den anderenn - mElementeninitialisiertwerden werden, wenn möglich, wertinitialisiert (siehe unten für die Erläuterung des Begriffs),
andernfalls, wenn (m> n)
der Compiler einen Fehler
ausgibt, andernfalls (dies ist der Fall, wenn n überhaupt nicht wie angegeben ist int a[] = {1, 2, 3};)
die Größe von Es wird angenommen, dass das Array (n) gleich m ist, alsoint a[] = {1, 2, 3};äquivalent zuint a[3] = {1, 2, 3};
Wenn ein Objekt von skalaren Typ ( bool, int, char, double, Zeiger, etc.) ist Wert initialisiert es bedeutet , dass es mit initialisiert wird 0für diesen Typen ( falsefür bool, 0.0für double, etc.). Wenn ein Objekt vom Klassentyp mit einem vom Benutzer deklarierten Standardkonstruktor wertinitialisiert wird, wird sein Standardkonstruktor aufgerufen. Wenn der Standardkonstruktor implizit definiert ist, werden alle nicht statischen Elemente rekursiv wertinitialisiert. Diese Definition ist ungenau und etwas falsch, sollte Ihnen aber die Grundidee vermitteln. Eine Referenz kann nicht wertinitialisiert werden. Die Wertinitialisierung für eine nicht aggregierte Klasse kann fehlschlagen, wenn die Klasse beispielsweise keinen geeigneten Standardkonstruktor hat.
Beispiele für die Array-Initialisierung:
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
}
Nun wollen wir sehen, wie Aggregatklassen mit geschweiften Klammern initialisiert werden können. So ziemlich genauso. Anstelle der Array-Elemente werden die nicht statischen Datenelemente in der Reihenfolge ihres Auftretens in der Klassendefinition initialisiert (sie sind alle per Definition öffentlich). Wenn weniger Initialisierer als Mitglieder vorhanden sind, wird der Rest wertinitialisiert. Wenn es unmöglich ist, eines der Mitglieder, die nicht explizit initialisiert wurden, mit einem Wert zu initialisieren, wird ein Fehler bei der Kompilierung angezeigt. Wenn mehr Initialisierer als erforderlich vorhanden sind, wird auch ein Fehler bei der Kompilierung angezeigt.
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}};
In dem obigen Beispiel y.cwird initialisiert mit 'a', y.x.i1mit 10, y.x.i2mit 20, y.i[0]mit 20, y.i[1]mit 30und y.fist Wert initialisiert, die mit wird, initialisiert 0.0. Das geschützte statische Element dwird überhaupt nicht initialisiert, da dies der Fall ist static.
Aggregierte Gewerkschaften unterscheiden sich darin, dass Sie nur ihr erstes Mitglied mit geschweiften Klammern initialisieren können. Ich denke, wenn Sie in C ++ weit genug fortgeschritten sind, um überhaupt die Verwendung von Gewerkschaften in Betracht zu ziehen (ihre Verwendung kann sehr gefährlich sein und sorgfältig überlegt werden müssen), könnten Sie die Regeln für Gewerkschaften im Standard selbst nachschlagen :).
Nachdem wir nun wissen, was das Besondere an Aggregaten ist, versuchen wir, die Einschränkungen für Klassen zu verstehen. das ist, warum sie dort sind. Wir sollten verstehen, dass die initiale Initialisierung mit geschweiften Klammern impliziert, dass die Klasse nichts anderes als die Summe ihrer Mitglieder ist. Wenn ein benutzerdefinierter Konstruktor vorhanden ist, bedeutet dies, dass der Benutzer zusätzliche Arbeit leisten muss, um die Elemente zu initialisieren. Daher wäre die Klammerinitialisierung falsch. Wenn virtuelle Funktionen vorhanden sind, bedeutet dies, dass die Objekte dieser Klasse (bei den meisten Implementierungen) einen Zeiger auf die sogenannte vtable der Klasse haben, die im Konstruktor festgelegt ist, sodass eine Klammerinitialisierung unzureichend wäre. Sie könnten den Rest der Einschränkungen auf ähnliche Weise wie bei einer Übung herausfinden :).
Also genug über die Aggregate. Jetzt können wir eine strengere Menge von Typen definieren, nämlich PODs
Was sind PODs und warum sind sie etwas Besonderes?
Formale Definition aus dem C ++ - Standard ( C ++ 03 9 §4 ) :
Eine POD-Struktur ist eine Aggregatklasse, die keine nicht statischen Datenelemente vom Typ Nicht-POD-Struktur, Nicht-POD-Vereinigung (oder Array solcher Typen) oder Referenz enthält und keinen benutzerdefinierten Kopierzuweisungsoperator und keine hat benutzerdefinierter Destruktor. In ähnlicher Weise ist eine POD-Vereinigung eine aggregierte Vereinigung, die keine nicht statischen Datenelemente vom Typ Nicht-POD-Struktur, Nicht-POD-Vereinigung (oder Array solcher Typen) oder Referenz enthält und keinen benutzerdefinierten Kopierzuweisungsoperator hat und kein benutzerdefinierter Destruktor. Eine POD-Klasse ist eine Klasse, die entweder eine POD-Struktur oder eine POD-Union ist.
Wow, das ist schwieriger zu analysieren, nicht wahr? :) Lassen wir die Gewerkschaften aus (aus den gleichen Gründen wie oben) weg und formulieren sie etwas klarer:
Eine Aggregatklasse wird als POD bezeichnet, wenn sie keinen benutzerdefinierten Operator und Destruktor für die Kopierzuweisung hat und keines ihrer nicht statischen Elemente eine Nicht-POD-Klasse, ein Array von Nicht-POD oder eine Referenz ist.
Was bedeutet diese Definition? (Habe ich erwähnt, dass POD für Plain Old Data steht ?)
- Alle POD-Klassen sind Aggregate, oder anders ausgedrückt: Wenn eine Klasse kein Aggregat ist, ist sie sicher kein POD
- Klassen können genau wie Strukturen PODs sein, obwohl der Standardbegriff in beiden Fällen POD-Struktur ist
- Genau wie bei Aggregaten spielt es keine Rolle, welche statischen Elemente die Klasse hat
Beispiele:
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
};
POD-Klassen, POD-Vereinigungen, Skalartypen und Arrays solcher Typen werden zusammen als POD-Typen bezeichnet.
PODs sind in vielerlei Hinsicht etwas Besonderes. Ich werde nur einige Beispiele nennen.
POD-Klassen sind C-Strukturen am nächsten. Im Gegensatz zu ihnen können PODs Elementfunktionen und beliebige statische Elemente haben, aber keines dieser beiden Elemente ändert das Speicherlayout des Objekts. Wenn Sie also eine mehr oder weniger portable dynamische Bibliothek schreiben möchten, die von C und sogar von .NET aus verwendet werden kann, sollten Sie versuchen, alle exportierten Funktionen dazu zu bringen, nur Parameter von POD-Typen zu übernehmen und zurückzugeben.
Die Lebensdauer von Objekten vom Nicht-POD-Klassentyp beginnt mit dem Abschluss des Konstruktors und endet mit dem Abschluss des Destruktors. Bei POD-Klassen beginnt die Lebensdauer, wenn der Speicher für das Objekt belegt ist, und endet, wenn dieser Speicher freigegeben oder wiederverwendet wird.
Für Objekte vom Typ POD wird durch den Standard garantiert , dass das Objekt seinen ursprünglichen Wert memcpybehält, wenn Sie den Inhalt Ihres Objekts in ein Array von Zeichen oder Zeichen ohne Vorzeichen und dann memcpyden Inhalt zurück in Ihr Objekt legen. Beachten Sie, dass für Objekte ohne POD-Typ keine solche Garantie besteht. Sie können POD-Objekte auch sicher mit kopieren memcpy. Im folgenden Beispiel wird davon ausgegangen, dass T ein POD-Typ ist:
#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
gehe zu Aussage. Wie Sie vielleicht wissen, ist es illegal (der Compiler sollte einen Fehler ausgeben), einen Sprung über goto von einem Punkt, an dem eine Variable noch nicht im Gültigkeitsbereich war, zu einem Punkt zu machen, an dem sie bereits im Gültigkeitsbereich liegt. Diese Einschränkung gilt nur, wenn die Variable vom Typ Nicht-POD ist. Im folgenden Beispiel f()ist schlecht geformt, während g()es gut geformt ist. Beachten Sie, dass der Compiler von Microsoft mit dieser Regel zu liberal ist. In beiden Fällen wird lediglich eine Warnung ausgegeben.
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;
}
Es wird garantiert, dass am Anfang eines POD-Objekts keine Auffüllung erfolgt. Mit anderen Worten, wenn das erste Element einer POD-Klasse A vom Typ T ist, können Sie sicher reinterpret_castvon A*zu T*und den Zeiger auf das erste Element erhalten und umgekehrt.
Die Liste geht weiter und weiter…
Fazit
Es ist wichtig zu verstehen, was genau ein POD ist, da sich viele Sprachfunktionen, wie Sie sehen, für sie unterschiedlich verhalten.