Nasıl okunur:
Bu makale oldukça uzun. Hem agregaları hem de POD'ları (Düz Eski Veriler) bilmek istiyorsanız, zaman ayırın ve okuyun. Sadece agregalarla ilgileniyorsanız, sadece ilk kısmı okuyun. Yalnızca PODs ilgilenen varsa o zaman ilk agrega tanımı, etkileri ve örnekler okumalı ve sonra olabilecek PODs atlamak ama hala kendi bütünlüğü içinde birinci bölümünü okuduğunuz öneriyoruz. Agrega kavramı POD'ları tanımlamak için gereklidir. Herhangi bir hata bulursanız (dilbilgisi, üslup, biçimlendirme, sözdizimi vb. Dahil olmak üzere küçük bile olsa) lütfen yorum bırakın, düzenleyeceğim.
Bu cevap C ++ 03 için geçerlidir. Diğer C ++ standartları için bakınız:
Agrega nedir ve neden özeldir?
C ++ standardından biçimsel tanım ( C ++ 03 8.5.1 §1 ) :
Toplama, kullanıcı tarafından bildirilen kurucuları (12.1), özel veya korumalı statik olmayan veri üyeleri (madde 11), temel sınıflar (madde 10) ve sanal işlevler (10.3) bulunmayan bir dizi veya sınıftır (madde 9). ).
Tamam, bu tanımı ayrıştıralım. Her şeyden önce, herhangi bir dizi bir kümedir. Bir sınıf aynı zamanda… bekle! yapılar veya sendikalar hakkında hiçbir şey söylenmez, bunlar küme olamazlar mı? Evet yapabilirler. C ++ 'da, terim classtüm sınıfları, yapıları ve birlikleri ifade eder. Dolayısıyla, bir sınıf (ya da yapı ya da birlik), yalnızca yukarıdaki tanımlardan gelen kriterleri karşıladığında toplanır. Bu kriterler ne anlama geliyor?
Bu, bir toplu sınıfın yapıcılara sahip olamayacağı anlamına gelmez, aslında derleyici tarafından açıkça belirtildiği ve kullanıcı tarafından açıkça belirtilmediği sürece varsayılan bir kurucuya ve / veya bir kopya kurucuya sahip olabileceği anlamına gelmez.
Özel veya korumalı statik olmayan veri üyeleri yok . Toplama sınıflarının kurallarını ihlal ettiğiniz gibi istediğiniz kadar özel ve korumalı üye işlevinizin (ancak yapıcıların değil) yanı sıra istediğiniz kadar özel veya korumalı statik veri üyesine ve üye işlevine sahip olabilirsiniz
Bir toplu sınıf, kullanıcı tarafından bildirilen / kullanıcı tanımlı bir kopya atama işleci ve / veya yıkıcıya sahip olabilir
Bir dizi, birleştirilmiş olmayan sınıf türü dizisi olsa bile bir toplamdır.
Şimdi bazı örneklere bakalım:
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
};
Kaptın bu işi. Şimdi toplamların nasıl özel olduğunu görelim. Agrega olmayan sınıflardan farklı olarak, kıvırcık parantezlerle başlatılabilirler {}. Bu başlatma sözdizimi, diziler için yaygın olarak bilinir ve bunların toplamlar olduğunu öğrendik. Öyleyse onlarla başlayalım.
Type array_name[n] = {a1, a2, …, am};
(m == n) ise
i inci dizinin elemanı ile başlatılır ı
başka, eğer (m, <n)
dizinin ilk m elemanları ile başlatılır 1 , bir 2 , ..., bir m ve diğern - melemanlar mümkünse vardır değer başlatıldı (terimin açıklama için aşağıya bakınız)
else if (m> n)
bir hata mesajı üretir derleyici
başka (bu durumda olduğunda n gibi hiç belirtilmemişse int a[] = {1, 2, 3};)
boyutunu dizi (n), böylece buna eşit olduğu varsayılırint a[] = {1, 2, 3};eşdeğerdirint a[3] = {1, 2, 3};
Skalar tip (bir amacı zaman bool, int, char, double, işaretçiler, vs.) değer başlatıldı bunun ile başlatılır anlamına gelir 0, bu tür için ( falseiçin bool, 0.0için double, vs.). Kullanıcı tarafından bildirilen bir varsayılan kurucuya sahip sınıf türünde bir nesne değer-başlatıldığında, varsayılan kurucu çağrılır. Varsayılan kurucu örtük olarak tanımlanmışsa, tüm statik olmayan üyeler özyinelemeli olarak değer başlatılır. Bu tanım kesin değildir ve biraz yanlıştır, ancak size temel fikri vermelidir. Bir başvuru, değer başlatılamaz. Birleştirilmiş olmayan bir sınıf için değer başlatma, örneğin sınıfın uygun bir varsayılan kurucusu yoksa başarısız olabilir.
Dizi başlatma örnekleri:
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
}
Şimdi toplu sınıfların kaşlı ayraçlarla nasıl başlatılabileceğini görelim. Hemen hemen aynı şekilde. Dizi elemanları yerine, statik olmayan veri üyelerini sınıf tanımındaki görünümlerine göre başlatacağız (hepsi tanım gereği herkese açıktır). Üyelerden daha az başlatıcı varsa, geri kalanı değerle başlatılır. Açık bir şekilde başlatılmamış üyelerden birine değer vermek mümkün değilse, derleme zamanı hatası alırız. Gerekenden daha fazla başlatıcı varsa, derleme zamanı hatası da alırız.
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}};
Yukarıdaki örnekte y.c, ile 'a', y.x.i1ile 10, y.x.i2ile 20, y.i[0]ile 20, y.i[1]ile 30ve y.fdeğerle başlatılır, yani ile başlatılır 0.0. Korumalı statik üye dhiç başlatılmaz, çünkü öyle static.
Toplu sendikalar farklıdır, çünkü yalnızca ilk üyelerini parantezle başlatabilirsiniz. C ++ 'da sendika kullanmayı düşünecek kadar gelişmişseniz (kullanımları çok tehlikeli olabilir ve dikkatlice düşünülmelidir), standarttaki sendikaların kurallarına kendiniz bakabilirsiniz :).
Toplamlar hakkında neyin özel olduğunu bildiğimize göre, sınıflardaki kısıtlamaları anlamaya çalışalım; işte bu yüzden neden oradalar. Parantez ile üye olarak başlatmanın, sınıfın üyelerinin toplamından başka bir şey olmadığını ima ettiğini anlamalıyız. Kullanıcı tanımlı bir kurucu varsa, kullanıcının üyeleri başlatmak için fazladan bir iş yapması gerektiği anlamına gelir, bu nedenle küme ayracı başlatma yanlış olur. Sanal işlevler varsa, bu sınıftaki nesnelerin (çoğu uygulamada) yapıcıda ayarlanan sınıfın vtable'ı için bir işaretçi olduğu anlamına gelir, bu nedenle küme parantezinin başlatılması yetersiz olacaktır. Geri kalan kısıtlamaları bir egzersize benzer şekilde anlayabilirsiniz :).
Agregalar hakkında yeterli. Şimdi, POD'lara daha katı türler tanımlayabiliriz
POD'lar nedir ve neden özeldir?
C ++ standardından biçimsel tanım ( C ++ 03 9 §4 ) :
POD-yapı, POD-struct olmayan, POD-birliği olmayan (veya bu tür bir dizi) veya başvuru türünde statik olmayan veri üyelerine sahip olmayan ve kullanıcı tanımlı bir kopya atama operatörü olmayan ve hiçbir kullanıcı tanımlı yıkıcı. Benzer şekilde, POD-birliği, POD-yapı olmayan, POD-birliği olmayan (veya bu tür bir dizi) veya başvuru türünde statik olmayan veri üyelerine sahip olmayan ve kullanıcı tanımlı bir kopya atama operatörü olmayan bir toplu birliktir ve kullanıcı tanımlı yıkıcı yok. POD sınıfı, POD yapısı veya POD birleşimi olan bir sınıftır.
Vay canına, bu ayrıştırmak daha zor, değil mi? :) Sendikaları dışarıda bırakalım (yukarıdakiyle aynı gerekçelerle) ve biraz daha açık bir şekilde yeniden ifade edelim:
Kullanıcı sınıfı tanımlı bir kopya atama işleci ve yıkıcısı yoksa ve statik olmayan üyelerinden hiçbiri POD olmayan bir sınıf, POD olmayan bir dizi veya bir başvuru değilse, toplu sınıf POD olarak adlandırılır.
Bu tanım ne anlama geliyor? ( POD'un Eski Düz Veri anlamına geldiğinden bahsetmiş miydim ?)
- Tüm POD sınıfları topludır veya başka bir deyişle, sınıf bir toplu değilse, POD olmadığından emin olur
- Sınıflar, tıpkı yapılar gibi, standart terim her iki durum için de POD yapısı olsa da POD olabilir
- Toplamalarda olduğu gibi, sınıfın hangi statik üyelere sahip olduğu önemli değildir
Örnekler:
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 sınıfları, POD-birlikleri, skaler tipler ve bu tipteki diziler topluca POD-tipleri olarak adlandırılır .
POD'lar birçok açıdan özeldir. Sadece bazı örnekler vereceğim.
POD sınıfları C yapılarına en yakın olanlardır. Bunlardan farklı olarak, POD'larda üye işlevleri ve rastgele statik üyeler olabilir, ancak bu ikisinden hiçbiri nesnenin bellek düzenini değiştirmez. Bu nedenle, C ve hatta .NET'ten kullanılabilecek az çok taşınabilir bir dinamik kitaplık yazmak istiyorsanız, dışa aktarılan tüm işlevlerinizi yalnızca POD tipi parametrelerini alıp döndürmeye çalışmalısınız.
POD sınıfı olmayan türdeki nesnelerin ömrü, kurucu tamamlandığında başlar ve yıkıcı tamamlandığında sona erer. POD sınıfları için ömür, nesne için depolama alanı dolduğunda başlar ve bu depolama alanı bırakıldığında veya yeniden kullanıldığında sona erer.
POD türündeki nesneler için, standart tarafından, memcpynesnenizin içeriğini bir char veya unsigned char dizisine ve daha memcpysonra içeriğin nesnenize geri döndüğünde, nesnenin orijinal değerini koruyacağı garanti edilir . POD olmayan türler için böyle bir garanti olmadığını unutmayın. Ayrıca, POD nesnelerini ile güvenle kopyalayabilirsiniz memcpy. Aşağıdaki örnekte T'nin POD tipi olduğu varsayılmaktadır:
#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
ifadeye git. Bildiğiniz gibi, bazı değişkenlerin henüz kapsamda olmadığı bir noktadan halihazırda kapsamda olan bir noktaya goto aracılığıyla bir sıçrama yapmak yasadışıdır (derleyici bir hata vermelidir). Bu kısıtlama yalnızca değişken POD olmayan türdeyse geçerlidir. Aşağıdaki örnekte iyi f()biçimlendirilmiş, kötü g()biçimlendirilmiş. Microsoft'un derleyicisinin bu kuralla çok liberal olduğunu unutmayın; her iki durumda da bir uyarı verir.
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;
}
Bir POD nesnesinin başlangıcında dolgu olmayacağı garanti edilir. POD sınıfı A'nın birinci eleman türü T ise, başka bir deyişle, güvenli bir şekilde olabilir reinterpret_castgelen A*için T*işaretçi ve elde tersi birinci eleman ve yardımcısı.
Liste uzayıp gidiyor…
Sonuç
Bir POD'un tam olarak ne olduğunu anlamak önemlidir, çünkü gördüğünüz gibi birçok dil özelliği onlar için farklı davranır.