อ่านอย่างไร:
บทความนี้ค่อนข้างยาว หากคุณต้องการทราบเกี่ยวกับทั้งมวลรวมและ PODs (ข้อมูลเก่าธรรมดา) ต้องใช้เวลาและอ่านมัน หากคุณสนใจเพียงแค่มวลรวมอ่านส่วนแรกเท่านั้น หากคุณสนใจเฉพาะ POD คุณต้องอ่านคำนิยามความหมายและตัวอย่างของมวลรวมก่อนจากนั้นคุณอาจข้ามไปยัง POD แต่ฉันขอแนะนำให้อ่านส่วนแรกอย่างครบถ้วน แนวคิดของมวลรวมเป็นสิ่งจำเป็นสำหรับการกำหนด POD หากคุณพบข้อผิดพลาดใด ๆ (แม้เล็กน้อยรวมถึงไวยากรณ์, โวหาร, การจัดรูปแบบ, ไวยากรณ์, ฯลฯ ) โปรดออกความคิดเห็นฉันจะแก้ไข
คำตอบนี้ใช้กับ C ++ 03 สำหรับมาตรฐาน C ++ อื่น ๆ ดูที่:
มวลรวมคืออะไรและเพราะเหตุใดจึงพิเศษ
การนิยามอย่างเป็นทางการจากมาตรฐานC ++ ( C ++ 03 8.5.1 §1 ) :
การรวมเป็นอาร์เรย์หรือคลาส (ข้อ 9) ที่ไม่มีตัวสร้างที่ประกาศโดยผู้ใช้ (12.1) ไม่มีสมาชิกข้อมูลส่วนตัวหรือป้องกันไม่คงที่ (มาตรา 11) ไม่มีคลาสพื้นฐาน (ข้อ 10) และไม่มีฟังก์ชั่นเสมือน (10.3) )
งั้นเรามาแยกคำนิยามนี้กัน ก่อนอื่นอาร์เรย์ใด ๆ จะเป็นผลรวม ชั้นเรียนอาจรวมกันได้หาก…รอ! ไม่มีอะไรพูดเกี่ยวกับ structs หรือ unions พวกมันรวมตัวกันไม่ได้เหรอ? ใช่พวกเขาสามารถ ใน C ++ คำนี้classหมายถึงคลาสโครงสร้างและสหภาพทั้งหมด ดังนั้นคลาส (หรือ struct หรือ union) จึงเป็นการรวมกันถ้าหากมันเป็นไปตามเกณฑ์จากคำจำกัดความข้างต้น เกณฑ์เหล่านี้หมายความว่าอย่างไร
นี่ไม่ได้หมายความว่าคลาสรวมจะไม่มีคอนสตรัคเตอร์ในความเป็นจริงมันสามารถมีคอนสตรัคเตอร์เริ่มต้นและ / หรือตัวสร้างการคัดลอกตราบใดที่พวกเขาถูกประกาศโดยปริยายโดยคอมไพเลอร์และไม่ชัดเจนโดยผู้ใช้
ไม่มีส่วนตัวหรือการคุ้มครองข้อมูลสมาชิกไม่คงที่ คุณสามารถมีฟังก์ชั่นส่วนตัวและสมาชิกที่ได้รับการป้องกันได้มาก (แต่ไม่ใช่คอนสตรัคเตอร์) รวมถึงสมาชิกข้อมูลส่วนตัวและฟังก์ชั่นสแตติกที่มีการป้องกันหรือส่วนตัวตามที่คุณต้องการและไม่ละเมิดกฎสำหรับคลาสรวม
คลาสรวมสามารถมีโอเปอเรเตอร์ที่ได้รับมอบหมายจากผู้ใช้ / ผู้ใช้กำหนดเองและ / หรือ destructor
อาร์เรย์เป็นผลรวมแม้ว่าจะเป็นอาร์เรย์ของประเภทคลาสที่ไม่รวม
ตอนนี้ลองมาดูตัวอย่าง:
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
};
คุณได้รับความคิด ตอนนี้เรามาดูกันว่าผลรวมมีความพิเศษอย่างไร {}พวกเขาแตกต่างจากการเรียนที่ไม่รวมสามารถเริ่มต้นได้ด้วยวงเล็บปีกกา ไวยากรณ์เริ่มต้นนี้เป็นที่รู้จักกันทั่วไปสำหรับอาร์เรย์และเราเพิ่งเรียนรู้ว่าสิ่งเหล่านี้เป็นผลรวม ดังนั้นเรามาเริ่มด้วยกัน
Type array_name[n] = {a1, a2, …, am};
ถ้า (m == n)
ฉัน THองค์ประกอบของอาร์เรย์จะเริ่มต้นกับฉัน
อื่นถ้า (m <n)
องค์ประกอบมแรกของอาร์เรย์จะเริ่มต้นด้วย 1เป็น 2 ... เป็นเมตรและอื่น ๆn - mองค์ประกอบ ถ้าเป็นไปได้ค่าเริ่มต้น (ดูด้านล่างสำหรับคำอธิบายของคำ
อื่น )ถ้า (m> n)
คอมไพเลอร์จะออกข้อผิดพลาด
อื่น (นี่คือกรณีที่ n ไม่ได้ระบุint a[] = {1, 2, 3};
ขนาดเหมือนกัน)อาร์เรย์ (n) จะถือว่าเท่ากับ m ดังนั้นจึงint a[] = {1, 2, 3};เท่ากับint a[3] = {1, 2, 3};
เมื่อวัตถุประเภทสเกลาร์ (เป็นbool, int, char, doubleตัวชี้ ฯลฯ ) เป็นมูลค่าเริ่มต้นมันหมายความว่ามันจะเริ่มต้นได้ด้วย0สำหรับประเภทที่ ( falseสำหรับbool, 0.0สำหรับdoubleฯลฯ ) เมื่อออบเจ็กต์ประเภทคลาสที่มีคอนสตรัคเตอร์เริ่มต้นที่ผู้ใช้ประกาศถูกกำหนดค่าเริ่มต้นมันจะเรียกคอนสตรัคเตอร์เริ่มต้น ถ้าคอนสตรัคเตอร์เริ่มต้นถูกกำหนดโดยปริยายแล้วสมาชิก nonstatic ทั้งหมดจะถูกกำหนดค่าเริ่มต้นซ้ำ คำจำกัดความนี้ไม่ถูกต้องและค่อนข้างไม่ถูกต้อง แต่ควรให้แนวคิดพื้นฐานแก่คุณ การอ้างอิงไม่สามารถกำหนดค่าเริ่มต้นได้ การกำหนดค่าเริ่มต้นสำหรับคลาสที่ไม่มีการรวมสามารถล้มเหลวได้ตัวอย่างเช่นหากคลาสนั้นไม่มีคอนสตรัคเตอร์เริ่มต้นที่เหมาะสม
ตัวอย่างของการเริ่มต้นอาร์เรย์:
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
}
ตอนนี้เรามาดูวิธีการรวมคลาสสามารถเริ่มต้นด้วยวงเล็บปีกกา ค่อนข้างเหมือนกัน แทนที่จะเป็นองค์ประกอบอาร์เรย์เราจะเริ่มต้นสมาชิกข้อมูลที่ไม่คงที่ตามลำดับของการปรากฏตัวของพวกเขาในการกำหนดระดับ (พวกเขาทั้งหมดสาธารณะตามคำนิยาม) หากมี initializers น้อยกว่าสมาชิกส่วนที่เหลือจะถูกกำหนดค่าเริ่มต้น หากไม่สามารถกำหนดค่าเริ่มต้นให้กับหนึ่งในสมาชิกที่ไม่ได้เริ่มต้นอย่างชัดเจนเราจะได้รับข้อผิดพลาดในการรวบรวมเวลา หากมี initializers มากกว่าที่จำเป็นเราจะได้รับข้อผิดพลาดในการคอมไพล์เช่นกัน
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}};
ในตัวอย่างข้างต้นy.cจะเริ่มต้นด้วย'a', y.x.i1กับ10, y.x.i2กับ20, y.i[0]กับ20, y.i[1]ด้วย30และเป็นมูลค่าเริ่มต้นที่เป็นเริ่มต้นได้ด้วยy.f 0.0สมาชิกคงได้รับการคุ้มครองไม่ได้เริ่มต้นที่ทุกคนเพราะมันเป็นdstatic
สหภาพการรวมจะแตกต่างกันซึ่งคุณสามารถเริ่มต้นได้เฉพาะสมาชิกแรกของพวกเขาด้วยเครื่องหมายปีกกา ฉันคิดว่าถ้าคุณมีความก้าวหน้าเพียงพอใน C ++ เพื่อพิจารณาการใช้สหภาพ (การใช้งานของพวกเขาอาจเป็นอันตรายมากและต้องพิจารณาอย่างรอบคอบ) คุณสามารถค้นหากฎสำหรับสหภาพในมาตรฐานของคุณเอง :)
ตอนนี้เรารู้แล้วว่ามีอะไรพิเศษเกี่ยวกับการรวมตัวลองมาทำความเข้าใจข้อ จำกัด ของคลาส นั่นคือเหตุผลที่พวกเขาอยู่ที่นั่น เราควรเข้าใจว่าการกำหนดค่าเริ่มต้นแบบสมาชิกด้วยวงเล็บปีกกาหมายความว่าชั้นเรียนนั้นไม่มีอะไรมากไปกว่าผลรวมของสมาชิก หากมีคอนสตรัคเตอร์ที่ผู้ใช้กำหนดเองแสดงว่าผู้ใช้ต้องทำงานพิเศษบางอย่างเพื่อเริ่มต้นสมาชิกดังนั้นการเตรียมใช้งานวงเล็บปีกกาจะไม่ถูกต้อง หากมีฟังก์ชั่นเสมือนจริงแสดงว่าวัตถุของคลาสนี้มีตัวชี้ไปยัง vtable ที่เรียกว่าคลาสซึ่งตั้งอยู่ในตัวสร้างดังนั้นในวงเล็บจะเริ่มต้นไม่เพียงพอ คุณสามารถหาข้อ จำกัด ที่เหลือในลักษณะเดียวกันกับแบบฝึกหัด :)
เพียงพอเกี่ยวกับมวลรวม ตอนนี้เราสามารถกำหนดชุดประเภทที่เข้มงวดเพื่อปัญญา POD
POD คืออะไรและทำไมจึงเป็นพิเศษ
การนิยามอย่างเป็นทางการจากมาตรฐานC ++ ( C ++ 03 9 §4 ) :
POD-struct เป็นคลาสรวมที่ไม่มีสมาชิกข้อมูลที่ไม่คงที่ประเภท non-POD-struct, non-POD-union (หรืออาเรย์ประเภทดังกล่าว) หรือการอ้างอิงและไม่มีผู้ประกอบการมอบหมายการคัดลอกที่กำหนดโดยผู้ใช้และไม่มี destructor ที่ผู้ใช้กำหนด ในทำนองเดียวกัน POD-union เป็นสหภาพรวมที่ไม่มีสมาชิกข้อมูลที่ไม่คงที่ประเภท non-POD-struct, non-POD-union (หรืออาร์เรย์ประเภทดังกล่าว) หรือการอ้างอิงและไม่มีผู้ประกอบการมอบหมายการคัดลอกที่ผู้ใช้กำหนด และไม่มี destructor ที่ผู้ใช้กำหนด คลาส POD เป็นคลาสที่เป็น POD-struct หรือ POD-union
ว้าวคนนี้แกร่งกว่าที่จะแยกวิเคราะห์ใช่ไหม? :) ปล่อยให้สหภาพแรงงานออกมา (ในบริเวณเดียวกับด้านบน) และใช้ถ้อยคำใหม่ในวิธีที่ชัดเจนขึ้น:
คลาสรวมเรียกว่า POD หากไม่มีโอเปอเรเตอร์การคัดลอกที่กำหนดโดยผู้ใช้และ destructor และไม่มีสมาชิกที่ไม่ใช่สมาชิกของมันคือคลาส non-POD, อาเรย์ของ non-POD หรือการอ้างอิง
คำจำกัดความนี้หมายถึงอะไร (ฉันพูดถึงPODย่อมาจากPlain Old Dataหรือไม่)
- คลาส POD ทั้งหมดเป็นผลรวมหรือถ้าจะให้เป็นอย่างอื่นถ้าคลาสนั้นไม่ใช่ผลรวมก็ไม่แน่ใจว่าเป็น POD
- คลาสเช่นเดียวกับ structs สามารถเป็น POD แม้ว่าคำมาตรฐานคือ POD-struct สำหรับทั้งสองกรณี
- เช่นเดียวกับในกรณีของมวลรวมมันไม่สำคัญว่าสมาชิกแบบคงที่ในชั้นเรียนจะมีอะไร
ตัวอย่าง:
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, POD-unions, ประเภทสเกลาร์, และอาร์เรย์ของประเภทดังกล่าวเรียกว่าประเภท POD
ฝักเป็นพิเศษในหลาย ๆ ฉันจะให้ตัวอย่าง
POD-classes นั้นใกล้เคียงกับ C struct มากที่สุด ซึ่งแตกต่างจากพวกเขา POD สามารถมีฟังก์ชั่นสมาชิกและสมาชิกคงที่โดยพลการ แต่ทั้งสองไม่เปลี่ยนแปลงรูปแบบหน่วยความจำของวัตถุ ดังนั้นหากคุณต้องการเขียนไลบรารี่แบบพกพาที่มากขึ้นหรือน้อยลงที่สามารถใช้งานได้จาก C และแม้แต่. NET คุณควรพยายามทำให้ฟังก์ชั่นที่ส่งออกทั้งหมดใช้และส่งคืนพารามิเตอร์ประเภท POD เท่านั้น
อายุการใช้งานของออบเจ็กต์ที่ไม่ใช่ประเภทคลาส POD เริ่มต้นเมื่อตัวสร้างเสร็จสิ้นและสิ้นสุดลงเมื่อตัวทำลายเสร็จสิ้น สำหรับคลาส POD อายุการใช้งานเริ่มต้นเมื่อมีการจัดเก็บข้อมูลสำหรับวัตถุและเสร็จสิ้นเมื่อมีการนำออกใช้หรือนำมาใช้อีกครั้ง
สำหรับออบเจกต์ของประเภท POD จะมีการรับประกันตามมาตรฐานที่เมื่อคุณmemcpyเนื้อหาของวัตถุของคุณเป็นอาร์เรย์ของถ่านหรือถ่านที่ไม่ได้ลงนามแล้วmemcpyเนื้อหากลับเข้าไปในวัตถุของคุณวัตถุจะเก็บค่าเดิม โปรดทราบว่าไม่มีการรับประกันดังกล่าวสำหรับวัตถุที่ไม่ใช่ POD นอกจากนี้คุณยังสามารถคัดลอกวัตถุ POD memcpyกับ ตัวอย่างต่อไปนี้สมมติว่า T เป็นชนิด 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
คำสั่ง goto อย่างที่คุณอาจจะรู้ว่ามันผิดกฎหมาย (คอมไพเลอร์ควรออกข้อผิดพลาด) เพื่อทำการกระโดดผ่าน goto จากจุดที่ตัวแปรบางตัวยังไม่อยู่ในขอบเขตจนถึงจุดที่มันอยู่ในขอบเขตแล้ว ข้อ จำกัด นี้ใช้เฉพาะในกรณีที่ตัวแปรเป็นประเภทที่ไม่ใช่ POD ในตัวอย่างต่อไปนี้f()เป็นรูปแบบไม่ดีในขณะที่g()มีรูปแบบที่ดี โปรดทราบว่าคอมไพเลอร์ของ Microsoft เปิดเสรีเกินไปกับกฎนี้ - เพียงแค่ออกคำเตือนในทั้งสองกรณี
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;
}
มีการรับประกันว่าจะไม่มีช่องว่างภายในในการเริ่มต้นของวัตถุ POD ในคำอื่น ๆ ถ้า POD ระดับของสมาชิกคนแรกเป็นประเภท T, คุณสามารถได้อย่างปลอดภัยreinterpret_castจากA*ไปT*และได้รับการชี้ไปยังสมาชิกคนแรกและในทางกลับกัน
รายการไปบนและบน…
ข้อสรุป
เป็นสิ่งสำคัญที่จะต้องเข้าใจว่า POD คืออะไรเพราะมีคุณสมบัติทางภาษามากมายดังที่คุณเห็น