Cara membaca:
Artikel ini agak panjang. Jika Anda ingin tahu tentang agregat dan POD (Data Lama Biasa) luangkan waktu dan bacalah. Jika Anda tertarik hanya pada agregat, baca hanya bagian pertama. Jika Anda hanya tertarik pada POD maka Anda harus terlebih dahulu membaca definisi, implikasi, dan contoh agregat dan kemudian Anda dapat melompat ke POD tetapi saya masih akan merekomendasikan membaca bagian pertama secara keseluruhan. Gagasan agregat sangat penting untuk mendefinisikan POD. Jika Anda menemukan kesalahan (bahkan minor, termasuk tata bahasa, gaya bahasa, pemformatan, sintaksis, dll.) Silakan tinggalkan komentar, saya akan mengedit.
Jawaban ini berlaku untuk C ++ 03. Untuk standar C ++ lainnya, lihat:
Apa itu agregat dan mengapa mereka istimewa
Definisi formal dari standar C ++ ( C ++ 03 8.5.1 §1 ) :
Agregat adalah array atau kelas (klausa 9) tanpa konstruktor yang dideklarasikan pengguna (12.1), tidak ada anggota data non-statis pribadi atau yang dilindungi (klausa 11), tidak ada kelas dasar (klausa 10), dan tidak ada fungsi virtual (10.3 ).
Jadi, OK, mari kita uraikan definisi ini. Pertama-tama, array apa pun adalah agregat. Kelas juga bisa menjadi agregat jika ... tunggu! tidak ada yang dikatakan tentang struct atau serikat pekerja, tidak bisakah mereka agregat? Ya mereka bisa. Dalam C ++, istilah ini classmerujuk ke semua kelas, struct, dan serikat pekerja. Jadi, sebuah kelas (atau struct, atau union) adalah agregat jika dan hanya jika memenuhi kriteria dari definisi di atas. Apa yang tersirat dari kriteria ini?
Ini tidak berarti kelas agregat tidak dapat memiliki konstruktor, pada kenyataannya ia dapat memiliki konstruktor default dan / atau copy konstruktor selama mereka secara implisit dinyatakan oleh kompiler, dan tidak secara eksplisit oleh pengguna
Tidak ada anggota data non-statis pribadi atau yang dilindungi . Anda dapat memiliki banyak fungsi anggota pribadi dan terlindungi (tetapi bukan konstruktor) serta sebanyak mungkin fungsi data anggota dan statis anggota dan fungsi anggota sebanyak yang Anda suka dan tidak melanggar aturan untuk kelas agregat
Kelas agregat dapat memiliki operator penugasan dan / atau destruktor yang dideklarasikan oleh pengguna dan / atau yang ditentukan pengguna
Array adalah agregat bahkan jika itu adalah array tipe kelas non-agregat.
Sekarang mari kita lihat beberapa contoh:
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
};
Anda mendapatkan idenya. Sekarang mari kita lihat bagaimana agregat itu istimewa. Mereka, tidak seperti kelas non-agregat, dapat diinisialisasi dengan kurung kurawal {}. Sintaks inisialisasi ini umumnya dikenal untuk array, dan kami baru mengetahui bahwa ini adalah agregat. Jadi, mari kita mulai dengan mereka.
Type array_name[n] = {a1, a2, …, am};
if (m == n)
i th elemen dari array diinisialisasi dengan i
lain jika (m <n)
elemen m pertama dari array diinisialisasi dengan 1 , sebuah 2 , ..., a m dan lainnyan - melemen adalah, jika mungkin, nilai diinisialisasi (lihat di bawah untuk penjelasan istilah)
jika tidak (m> n)
kompiler akan mengeluarkan kesalahan
lain (ini adalah kasus ketika n tidak ditentukan sama sekali seperti int a[] = {1, 2, 3};)
ukuran array (n) diasumsikan sama dengan m, jadiint a[] = {1, 2, 3};sama denganint a[3] = {1, 2, 3};
Ketika sebuah objek dari tipe skalar ( bool, int, char, double, pointer, dll) adalah nilai-diinisialisasi itu berarti itu diinisialisasi dengan 0untuk jenis yang ( falseuntuk bool, 0.0untuk double, dll). Ketika objek tipe kelas dengan konstruktor default yang dideklarasikan pengguna diinisialisasi nilai konstruktor defaultnya disebut. Jika konstruktor default didefinisikan secara implisit, maka semua anggota nonstatis diinisialisasi nilai secara rekursif. Definisi ini tidak tepat dan sedikit salah tetapi seharusnya memberi Anda ide dasar. Referensi tidak dapat diinisialisasi nilai. Inisialisasi nilai untuk kelas non-agregat dapat gagal jika, misalnya, kelas tidak memiliki konstruktor default yang sesuai.
Contoh inisialisasi 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
}
Sekarang mari kita lihat bagaimana kelas agregat dapat diinisialisasi dengan kawat gigi. Hampir sama caranya. Alih-alih elemen array kita akan menginisialisasi anggota data non-statis dalam urutan penampilan mereka di definisi kelas (mereka semua publik menurut definisi). Jika ada lebih sedikit inisialisasi daripada anggota, sisanya diinisialisasi-nilai. Jika tidak mungkin untuk menginisialisasi nilai salah satu anggota yang tidak diinisialisasi secara eksplisit, kami mendapatkan kesalahan waktu kompilasi. Jika ada lebih banyak inisialisasi dari yang diperlukan, kami juga mendapatkan kesalahan waktu kompilasi.
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}};
Dalam contoh di atas y.cdiinisialisasi dengan 'a', y.x.i1dengan 10, y.x.i2dengan 20, y.i[0]dengan 20, y.i[1]dengan 30dan y.fdiinisialisasi-nilai, yaitu diinisialisasi dengan 0.0. Anggota statis yang dilindungi dtidak diinisialisasi sama sekali, karena memang demikian static.
Agregat serikat berbeda karena Anda dapat menginisialisasi hanya anggota pertama mereka dengan kawat gigi. Saya pikir jika Anda cukup mahir dalam C ++ untuk bahkan mempertimbangkan menggunakan serikat pekerja (penggunaannya mungkin sangat berbahaya dan harus dipikirkan dengan hati-hati), Anda bisa mencari aturan serikat pekerja dalam standar sendiri :).
Sekarang kita tahu apa yang istimewa tentang agregat, mari kita coba memahami batasan pada kelas; itulah sebabnya mereka ada di sana. Kita harus memahami bahwa inisialisasi berdasarkan anggota dengan kawat gigi menyiratkan bahwa kelas tidak lebih dari jumlah anggotanya. Jika ada konstruktor yang ditentukan pengguna, itu berarti bahwa pengguna perlu melakukan beberapa pekerjaan tambahan untuk menginisialisasi anggota sehingga inisialisasi brace akan salah. Jika ada fungsi virtual, itu berarti bahwa objek dari kelas ini memiliki (pada sebagian besar implementasi) pointer ke apa yang disebut vtable kelas, yang diatur dalam konstruktor, sehingga inisialisasi brace tidak akan cukup. Anda bisa mengetahui batasan lainnya dengan cara yang sama seperti latihan :).
Cukup tentang agregat. Sekarang kita dapat mendefinisikan serangkaian tipe yang lebih ketat, yaitu, POD
Apa itu POD dan mengapa mereka istimewa
Definisi formal dari standar C ++ ( C ++ 03 9 §4 ) :
POD-struct adalah kelas agregat yang tidak memiliki anggota data non-statis dari tipe non-POD-struct, non-POD-union (atau array jenis seperti itu) atau referensi, dan tidak memiliki operator penugasan salinan yang ditentukan pengguna dan tidak ada destructor yang ditentukan pengguna. Demikian pula, serikat POD adalah serikat agregat yang tidak memiliki anggota data non-statis dari tipe non-POD-struct, non-POD-union (atau array jenis seperti itu) atau referensi, dan tidak memiliki operator penugasan salinan yang ditentukan pengguna dan tidak ada destruktor yang ditentukan pengguna. Kelas POD adalah kelas yang merupakan POD-struct atau POD-union.
Wow, yang ini lebih sulit untuk diurai, bukan? :) Mari kita tinggalkan serikat pekerja (dengan alasan yang sama seperti di atas) dan ulangi dengan cara yang sedikit lebih jelas:
Kelas agregat disebut POD jika tidak memiliki operator penugasan dan penghancur salinan yang ditentukan pengguna dan tidak ada anggota non-statisnya yang merupakan kelas non-POD, array non-POD, atau referensi.
Apa arti definisi ini? (Apakah saya menyebutkan POD singkatan dari Plain Old Data ?)
- Semua kelas POD adalah agregat, atau, dengan kata lain, jika suatu kelas bukan agregat maka pasti bukan POD
- Kelas, seperti halnya struct, dapat menjadi PODs meskipun istilah standarnya adalah POD-struct untuk kedua kasus
- Sama seperti dalam kasus agregat, tidak masalah apa anggota statis kelas miliki
Contoh:
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
};
Kelas POD, serikat POD, tipe skalar, dan susunan tipe seperti itu secara kolektif disebut tipe POD.
POD spesial dalam banyak hal. Saya akan memberikan beberapa contoh saja.
Kelas POD adalah yang terdekat dengan C struct. Tidak seperti mereka, POD dapat memiliki fungsi anggota dan anggota statis sewenang-wenang, tetapi keduanya tidak mengubah tata letak memori objek. Jadi, jika Anda ingin menulis pustaka dinamis portabel yang kurang lebih dapat digunakan dari C dan bahkan. NET, Anda harus mencoba membuat semua fungsi yang diekspor mengambil dan hanya mengembalikan parameter tipe POD.
Masa objek objek non-POD kelas dimulai ketika konstruktor telah selesai dan berakhir ketika destruktor telah selesai. Untuk kelas POD, masa dimulai ketika penyimpanan untuk objek ditempati dan selesai ketika penyimpanan dilepaskan atau digunakan kembali.
Untuk objek tipe POD dijamin oleh standar bahwa ketika Anda memcpyisi objek Anda menjadi array char atau char unsigned, dan kemudian memcpykonten kembali ke objek Anda, objek akan memegang nilai aslinya. Perhatikan bahwa tidak ada jaminan untuk objek jenis non-POD. Anda juga dapat dengan aman menyalin objek POD memcpy. Contoh berikut menganggap T adalah tipe 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
pernyataan kebohongan. Seperti yang Anda ketahui, itu ilegal (kompiler harus mengeluarkan kesalahan) untuk melakukan lompatan melalui titik dari mana beberapa variabel belum dalam ruang lingkup ke titik di mana ia sudah dalam ruang lingkup. Pembatasan ini hanya berlaku jika variabelnya bukan tipe POD. Pada contoh berikut f()ini terbentuk buruk sedangkan terbentuk dengan g()baik. Perhatikan bahwa kompiler Microsoft terlalu liberal dengan aturan ini — ia hanya mengeluarkan peringatan dalam kedua kasus.
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;
}
Dijamin bahwa tidak akan ada padding di awal objek POD. Dengan kata lain, jika anggota pertama POD-kelas A adalah tipe T, Anda dapat dengan aman reinterpret_castdari A*ke T*dan mendapatkan pointer ke anggota pertama dan sebaliknya.
Daftar ini terus dan terus ...
Kesimpulan
Penting untuk memahami apa sebenarnya POD itu karena banyak fitur bahasa, seperti yang Anda lihat, berperilaku berbeda untuk mereka.