Jak to czytac:
Ten artykuł jest raczej długi. Jeśli chcesz wiedzieć zarówno o agregatach, jak i czujnikach POD (Plain Old Data), poświęć trochę czasu i przeczytaj je. Jeśli interesują Cię tylko agregaty, przeczytaj tylko pierwszą część. Jeśli jesteś zainteresowany tylko w strąkach potem trzeba najpierw przeczytać definicji, implikacje i przykłady kruszyw a następnie mogą przejść do POD ale ja i tak polecam czytać pierwszą część w całości. Pojęcie agregatów jest niezbędne do definiowania POD. Jeśli znajdziesz jakieś błędy (nawet drobne, w tym gramatykę, stylistykę, formatowanie, składnię itp.), Zostaw komentarz, będę edytować.
Ta odpowiedź dotyczy C ++ 03. Inne standardy C ++ patrz:
Co to są agregaty i dlaczego są wyjątkowe
Formalna definicja ze standardu C ++ ( C ++ 03 8.5.1 § 1 ) :
Agregacja to tablica lub klasa (klauzula 9) bez konstruktorów zadeklarowanych przez użytkownika (12.1), bez prywatnych lub chronionych niestatycznych elementów danych (klauzula 11), bez klas podstawowych (klauzula 10) i bez funkcji wirtualnych (10.3 ).
OK, przeanalizujmy tę definicję. Przede wszystkim każda tablica jest agregacją. Klasa może być również agregacją, jeśli… czekaj! nic nie mówi się o strukturach lub związkach, czy nie mogą być agregacjami? Tak, moga. W C ++ termin classodnosi się do wszystkich klas, struktur i związków. Tak więc klasa (lub struct lub union) jest agregatem tylko wtedy, gdy spełnia kryteria z powyższych definicji. Co oznaczają te kryteria?
Nie oznacza to, że klasa agregująca nie może mieć konstruktorów, w rzeczywistości może mieć domyślny konstruktor i / lub konstruktor kopii, o ile są one domyślnie zadeklarowane przez kompilator, a nie jawnie przez użytkownika
Brak prywatnych lub chronionych niestatycznych elementów danych . Możesz mieć dowolną liczbę prywatnych i chronionych funkcji składowych (ale nie konstruktorów), a także dowolną liczbę prywatnych lub chronionych statycznych elementów danych i funkcji składowych, jak chcesz i nie naruszać reguł dla klas agregujących
Klasa zagregowana może mieć zadeklarowany / zdefiniowany przez użytkownika operator przypisania kopii i / lub destruktor
Tablica jest agregatem, nawet jeśli jest tablicą typu klasy innej niż agregat.
Teraz spójrzmy na kilka przykładów:
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
};
Masz pomysł. Zobaczmy teraz, jak agregaty są wyjątkowe. W przeciwieństwie do klas niezagregowanych można je inicjować za pomocą nawiasów klamrowych {}. Ta składnia inicjalizacji jest powszechnie znana dla tablic i właśnie dowiedzieliśmy się, że są to agregaty. Zacznijmy od nich.
Type array_name[n] = {a1, a2, …, am};
if (m == n)
i- ty element tablicy jest inicjalizowany za pomocą i
else if (m <n)
pierwsze m elementów tablicy jest inicjalizowanych przez 1 , 2 ,…, mi pozostałen - melementy są, jeśli to możliwe, inicjowane wartością (wyjaśnienie terminu znajduje się poniżej)
, w przeciwnym razie, jeśli (m> n)
kompilator wygeneruje błąd w
innym przypadku (tak jest w przypadku, gdy n nie jest określone w ogóle int a[] = {1, 2, 3};)
rozmiar przyjmuje się, że tablica (n) jest równa m, więcint a[] = {1, 2, 3};jest równoważna zint a[3] = {1, 2, 3};
Gdy obiekt typu skalarną ( bool, int, char, double, wskaźniki, itp) jest wartość zainicjowany oznacza to, że jest inicjowana 0dla tego typu ( falseo bool, 0.0o double, etc.). Kiedy obiekt typu klasy z deklarowanym przez użytkownika domyślnym konstruktorem jest inicjowany wartością, wywoływany jest domyślny konstruktor. Jeśli domyślny konstruktor jest domyślnie zdefiniowany, wówczas wszystkie elementy niestatyczne są inicjowane rekurencyjnie pod względem wartości. Ta definicja jest nieprecyzyjna i nieco niepoprawna, ale powinna dać ci podstawowy pomysł. Nie można zainicjować wartości referencyjnej. Inicjalizacja wartości dla klasy niezagregowanej może się nie powieść, jeśli na przykład klasa nie ma odpowiedniego domyślnego konstruktora.
Przykłady inicjalizacji tablicy:
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
}
Zobaczmy teraz, jak można zainicjować klasy agregujące za pomocą nawiasów klamrowych. Prawie w ten sam sposób. Zamiast elementów tablicy zainicjalizujemy niestatyczne elementy danych w kolejności ich pojawienia się w definicji klasy (wszystkie są z definicji publiczne). Jeśli jest mniej inicjatorów niż członków, reszta jest inicjowana wartością. Jeśli nie można zainicjować wartości jednego z elementów, które nie zostały jawnie zainicjowane, pojawia się błąd czasu kompilacji. Jeśli jest więcej inicjatorów, niż to konieczne, otrzymujemy również błąd czasu kompilacji.
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}};
W powyższym przykładzie y.cjest inicjowana 'a', y.x.i1z 10, y.x.i2z 20, y.i[0]z 20, y.i[1]z 30, a y.fma wartość zainicjowany, to znaczy inicjowany 0.0. Chroniony element statyczny dw ogóle nie jest inicjowany, ponieważ tak jest static.
Łączne związki różnią się tym, że możesz inicjować tylko ich pierwszego członka za pomocą nawiasów klamrowych. Myślę, że jeśli jesteś wystarczająco zaawansowany w C ++, aby nawet rozważyć użycie związków (ich użycie może być bardzo niebezpieczne i należy o tym ostrożnie pomyśleć), możesz sam sprawdzić zasady dotyczące związków w standardzie :).
Teraz, gdy wiemy, co jest specjalnego w agregatach, spróbujmy zrozumieć ograniczenia dotyczące klas; to znaczy, dlaczego tam są. Powinniśmy zrozumieć, że inicjalizacja członowa za pomocą nawiasów oznacza, że klasa jest niczym więcej niż sumą jej elementów. Jeśli obecny jest konstruktor zdefiniowany przez użytkownika, oznacza to, że użytkownik musi wykonać dodatkową pracę, aby zainicjować elementy, dlatego inicjacja nawiasów byłaby niepoprawna. Jeśli obecne są funkcje wirtualne, oznacza to, że obiekty tej klasy mają (w większości implementacji) wskaźnik do tak zwanej vtable klasy, która jest ustawiona w konstruktorze, więc inicjacja nawiasów nie byłaby wystarczająca. Resztę ograniczeń możesz znaleźć w podobny sposób jak ćwiczenie :).
Tyle o agregatach. Teraz możemy zdefiniować bardziej rygorystyczny zestaw typów, to znaczy POD
Co to są POD i dlaczego są wyjątkowe
Formalna definicja ze standardu C ++ ( C ++ 03 9 §4 ) :
Struktura POD jest strukturą zagregowaną, która nie zawiera elementów niestatycznych typu non-POD-struct, non-POD-union (lub tablic takich typów) lub referencji i nie ma zdefiniowanego przez użytkownika operatora przypisania kopii i nie ma destruktor zdefiniowany przez użytkownika. Podobnie, związek POD jest związkiem zagregowanym, który nie ma elementów niestatycznych typu typu non-POD-struct, non-POD-union (lub tablica takich typów) lub odniesienia i nie ma operatora przypisania kopii zdefiniowanego przez użytkownika i brak niszczyciela zdefiniowanego przez użytkownika. Klasa POD to klasa będąca strukturą POD lub związkiem POD.
Wow, trudniej to przeanalizować, prawda? :) Pozostawmy związki (na tych samych podstawach, co powyżej) i sformułujmy je w nieco jaśniejszy sposób:
Klasa zagregowana jest nazywana POD, jeśli nie ma zdefiniowanego przez użytkownika operatora przypisania kopii i destruktora, a żaden z jej elementów niestatycznych nie jest klasą inną niż POD, tablicą non-POD ani referencją.
Co oznacza ta definicja? (Czy wspominałem o POD oznacza Plain Old Data ?)
- Wszystkie klasy POD są agregatami lub, inaczej mówiąc, jeśli klasa nie jest agregacją, to na pewno nie jest POD
- Klasy, podobnie jak struktury, mogą być POD, mimo że w obu przypadkach standardowym terminem jest POD-struct
- Podobnie jak w przypadku agregatów, nie ma znaczenia, jakie elementy statyczne ma klasa
Przykłady:
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
};
Klasy POD, związki POD, typy skalarne i tablice takich typów są wspólnie nazywane typami POD.
POD są wyjątkowe na wiele sposobów. Podam tylko kilka przykładów.
Klasy POD są najbliższe strukturom C. W przeciwieństwie do nich POD mogą mieć funkcje składowe i dowolne elementy statyczne, ale żadne z tych dwóch nie zmienia układu pamięci obiektu. Więc jeśli chcesz napisać mniej lub bardziej przenośną bibliotekę dynamiczną, z której można korzystać z C, a nawet .NET, powinieneś spróbować, aby wszystkie wyeksportowane funkcje przyjmowały i zwracały tylko parametry typów POD.
Żywotność obiektów klasy innej niż POD rozpoczyna się po zakończeniu konstruktora, a kończy po zakończeniu działania destruktora. W przypadku klas POD żywotność rozpoczyna się, gdy pamięć jest zajęta, i kończy się, gdy pamięć zostanie zwolniona lub ponownie użyta.
W przypadku obiektów typu POD norma gwarantuje, że gdy memcpyzawartość Twojego obiektu zostanie zapisana w tablicy znaków lub w postaci znaku bez znaku, a następnie memcpyzawartość z powrotem w twoim obiekcie, obiekt zachowa swoją oryginalną wartość. Należy pamiętać, że nie ma takiej gwarancji na obiekty innych niż POD. Możesz także bezpiecznie kopiować obiekty POD za pomocą memcpy. Poniższy przykład zakłada, że T jest typem 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
oświadczenie goto. Jak zapewne wiesz, nielegalne (kompilator powinien wydać błąd) jest przeskakiwanie za pomocą goto z miejsca, w którym jakaś zmienna nie była jeszcze w zasięgu, do punktu, w którym już jest w zasięgu. To ograniczenie ma zastosowanie tylko wtedy, gdy zmienna jest typu innego niż POD. W poniższym przykładzie f()jest źle uformowany, podczas gdy g()jest dobrze uformowany. Zauważ, że kompilator Microsoftu jest zbyt liberalny w stosunku do tej reguły - w obu przypadkach wydaje tylko ostrzeżenie.
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;
}
Gwarantujemy, że na początku obiektu POD nie będzie paddingu. Innymi słowy, jeśli pierwszy element klasy POD klasy A jest typu T, możesz bezpiecznie przejść reinterpret_castod i uzyskać wskaźnik do pierwszego elementu i odwrotnie.A*T*
Lista jest długa…
Wniosek
Ważne jest, aby zrozumieć, czym dokładnie jest POD, ponieważ wiele funkcji językowych, jak widzisz, zachowuje się dla nich inaczej.