บทนำ
C ++ ตัวแปรถือว่าผู้ใช้กำหนดประเภทที่มีความหมายค่า ซึ่งหมายความว่าวัตถุจะถูกคัดลอกโดยปริยายในบริบทต่าง ๆ และเราควรเข้าใจว่า "การคัดลอกวัตถุ" หมายถึงอะไรจริง ๆ
ขอให้เราพิจารณาตัวอย่างง่ายๆ
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age) : name(name), age(age)
{
}
};
int main()
{
person a("Bjarne Stroustrup", 60);
person b(a); // What happens here?
b = a; // And here?
}
(หากคุณสับสนโดยname(name), age(age)ส่วนนี้เรียกว่ารายการสมาชิกเริ่มต้น )
ฟังก์ชั่นสมาชิกพิเศษ
การคัดลอกpersonวัตถุหมายถึงอะไร mainฟังก์ชั่นแสดงให้เห็นสองสถานการณ์ที่แตกต่างกันการคัดลอก การเริ่มต้นperson b(a);ที่จะดำเนินการโดยตัวสร้างสำเนา หน้าที่ของมันคือการสร้างวัตถุใหม่ขึ้นอยู่กับสถานะของวัตถุที่มีอยู่ ได้รับมอบหมายb = aจะดำเนินการโดยผู้ประกอบการที่ได้รับมอบหมายสำเนา โดยทั่วไปแล้วงานของมันจะซับซ้อนกว่านี้เล็กน้อยเนื่องจากวัตถุเป้าหมายอยู่ในสถานะที่ถูกต้องบางอย่างที่ต้องได้รับการจัดการ
เนื่องจากเราไม่ได้ประกาศตัวสร้างสำเนาหรือตัวดำเนินการกำหนด (หรือตัวทำลาย) เองเราจึงกำหนดสิ่งเหล่านี้โดยปริยาย อ้างอิงจากมาตรฐาน:
ตัวสร้างการคัดลอก [... ] และตัวดำเนินการกำหนดค่าการคัดลอก [... ] และ destructor เป็นฟังก์ชันสมาชิกพิเศษ [ หมายเหตุ : การใช้งานจะประกาศฟังก์ชั่นสมาชิกเหล่านี้โดยนัยสำหรับคลาสบางประเภทเมื่อโปรแกรมไม่ได้ประกาศอย่างชัดเจน
การใช้งานจะกำหนดโดยนัยหากมีการใช้งาน [... ] end note ] [n3126.pdf ตอนที่ 12 §1]
โดยค่าเริ่มต้นการคัดลอกวัตถุหมายถึงการคัดลอกสมาชิก:
ตัวสร้างสำเนาที่กำหนดโดยนัยสำหรับ non-union class X ทำการคัดลอกรหัสสมาชิกของ subobjects [n3126.pdf ส่วนที่ 12.8 §16]
ตัวดำเนินการกำหนดค่าการคัดลอกที่กำหนดโดยนัยสำหรับ non-union class X ดำเนินการกำหนดสำเนาของสมาชิกย่อยของ subobjects [n3126.pdf ส่วนที่ 12.8 §30]
คำจำกัดความโดยนัย
ฟังก์ชั่นสมาชิกพิเศษที่กำหนดโดยนัยสำหรับpersonลักษณะดังนี้:
// 1. copy constructor
person(const person& that) : name(that.name), age(that.age)
{
}
// 2. copy assignment operator
person& operator=(const person& that)
{
name = that.name;
age = that.age;
return *this;
}
// 3. destructor
~person()
{
}
การคัดลอกแบบสมาชิกเป็นสิ่งที่เราต้องการในกรณีนี้
nameและageคัดลอกดังนั้นเราจึงได้personวัตถุที่มีอยู่ในตัวและเป็นอิสระ destructor ที่กำหนดโดยปริยายนั้นว่างเปล่าเสมอ ในกรณีนี้ก็ดีเช่นกันเนื่องจากเราไม่ได้รับทรัพยากรใด ๆ ในตัวสร้าง destructors ของสมาชิกจะถูกเรียกโดยปริยายหลังจากตัวpersonทำลายเสร็จสิ้น:
หลังจากดำเนินการร่างของ destructor และทำลายวัตถุอัตโนมัติใด ๆ ที่จัดสรรภายในร่างกาย destructor สำหรับคลาส X เรียก destructors สำหรับสมาชิก X โดยตรง [... ] [n3126.pdf 12.4 §6]
การจัดการทรัพยากร
ดังนั้นเมื่อไหร่เราจึงควรประกาศฟังก์ชั่นสมาชิกพิเศษเหล่านั้นอย่างชัดเจน? เมื่อคลาสของเราจัดการทรัพยากรนั่นคือเมื่อวัตถุของคลาสรับผิดชอบทรัพยากรนั้น ซึ่งมักจะหมายถึงทรัพยากรที่ได้มาในตัวสร้าง (หรือส่งผ่านไปยังตัวสร้าง) และปล่อยในตัวทำลาย
ให้เราย้อนเวลากลับไปสู่มาตรฐาน C ++ ล่วงหน้า ไม่มีสิ่งเช่นstd::stringนั้นและโปรแกรมเมอร์ก็หลงรักพอยน์เตอร์ personชั้นอาจจะมีการมองเช่นนี้
class person
{
char* name;
int age;
public:
// the constructor acquires a resource:
// in this case, dynamic memory obtained via new[]
person(const char* the_name, int the_age)
{
name = new char[strlen(the_name) + 1];
strcpy(name, the_name);
age = the_age;
}
// the destructor must release this resource via delete[]
~person()
{
delete[] name;
}
};
แม้กระทั่งทุกวันนี้ผู้คนยังคงเขียนคลาสในลักษณะนี้และมีปัญหา: " ฉันผลักคนไปสู่เวกเตอร์และตอนนี้ฉันได้รับข้อผิดพลาดที่หน่วยความจำบ้า! " โปรดจำไว้ว่าโดยค่าเริ่มต้นการคัดลอกวัตถุหมายถึงการคัดลอกnameสมาชิก คัดลอกตัวชี้ไม่ใช่อาร์เรย์อักขระที่ชี้ไป! สิ่งนี้มีผลกระทบที่ไม่พึงประสงค์หลายประการ:
- เปลี่ยนผ่านสามารถสังเกตได้ผ่านทาง
ab
- เมื่อ
bถูกทำลายa.nameจะเป็นตัวชี้ห้อย
- หาก
aถูกทำลายลบผลผลิตตัวชี้ห้อยไม่ได้กำหนดพฤติกรรม
- เนื่องจากการบ้านไม่ได้คำนึงถึงสิ่งที่
nameชี้ไปก่อนการมอบหมายไม่ช้าก็เร็วคุณจะได้รับการรั่วไหลของหน่วยความจำทั่วทุกสถานที่
คำจำกัดความที่ชัดเจน
เนื่องจากการคัดลอกแบบสมาชิกแบบไม่มีผลตามที่ต้องการเราต้องกำหนดตัวสร้างการคัดลอกและตัวดำเนินการกำหนดค่าการคัดลอกอย่างชัดเจนเพื่อทำสำเนาลึกของอาร์เรย์อักขระ:
// 1. copy constructor
person(const person& that)
{
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
// 2. copy assignment operator
person& operator=(const person& that)
{
if (this != &that)
{
delete[] name;
// This is a dangerous point in the flow of execution!
// We have temporarily invalidated the class invariants,
// and the next statement might throw an exception,
// leaving the object in an invalid state :(
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
return *this;
}
จดบันทึกความแตกต่างระหว่างการเริ่มต้นและการกำหนด: เราต้องทำลายสถานะเก่าก่อนกำหนดnameเพื่อป้องกันการรั่วไหลของหน่วยความจำ นอกจากนี้เรายังต้องป้องกันการมอบหมายรูปแบบx = xตนเอง หากไม่มีการตรวจสอบนั้นdelete[] nameจะลบอาร์เรย์ที่มีสตริงต้นฉบับเพราะเมื่อคุณเขียนx = xทั้งสองthis->nameและthat.nameมีตัวชี้เดียวกัน
ข้อยกเว้นด้านความปลอดภัย
น่าเสียดายที่โซลูชันนี้จะล้มเหลวหากnew char[...]ส่งข้อยกเว้นเนื่องจากหน่วยความจำหมด ทางออกหนึ่งที่เป็นไปได้คือการแนะนำตัวแปรท้องถิ่นและจัดลำดับคำสั่งใหม่:
// 2. copy assignment operator
person& operator=(const person& that)
{
char* local_name = new char[strlen(that.name) + 1];
// If the above statement throws,
// the object is still in the same state as before.
// None of the following statements will throw an exception :)
strcpy(local_name, that.name);
delete[] name;
name = local_name;
age = that.age;
return *this;
}
นอกจากนี้ยังดูแลการมอบหมายด้วยตนเองโดยไม่ตรวจสอบอย่างชัดเจน ทางออกที่แข็งแกร่งยิ่งขึ้นสำหรับปัญหานี้คือสำนวนคัดลอกและสลับแต่ฉันจะไม่เข้าไปดูรายละเอียดของข้อยกเว้นด้านความปลอดภัยที่นี่ ฉันพูดถึงข้อยกเว้นเท่านั้นเพื่อให้ประเด็นต่อไปนี้: การเขียนคลาสที่จัดการทรัพยากรทำได้ยาก
ทรัพยากรที่ไม่สามารถคัดลอกได้
ทรัพยากรบางอย่างไม่สามารถหรือไม่ควรคัดลอกเช่นตัวจัดการไฟล์หรือ mutex ในกรณีนี้ให้ประกาศตัวสร้างการคัดลอกและตัวดำเนินการกำหนดค่าการคัดลอกprivateโดยไม่ต้องให้คำจำกัดความ:
private:
person(const person& that);
person& operator=(const person& that);
หรือคุณสามารถรับช่วงต่อจากboost::noncopyableหรือประกาศเป็นลบ (ใน C ++ 11 ขึ้นไป):
person(const person& that) = delete;
person& operator=(const person& that) = delete;
กฎข้อที่สาม
บางครั้งคุณต้องใช้คลาสที่จัดการทรัพยากร (ไม่เคยจัดการทรัพยากรหลายอย่างในคลาสเดียวสิ่งนี้จะนำไปสู่ความเจ็บปวดเท่านั้น) ในกรณีนี้ให้จดจำกฎข้อที่สาม :
หากคุณต้องการประกาศตัว Destructor ตัวคัดลอก Constructor หรือตัวดำเนินการกำหนดค่าด้วยตนเองอย่างชัดเจนคุณอาจต้องประกาศทั้งสามอย่างชัดเจน
(น่าเสียดายที่ "กฎ" นี้ไม่ได้บังคับใช้โดยมาตรฐาน C ++ หรือคอมไพเลอร์ใด ๆ ที่ฉันรู้จัก)
กฎห้าข้อ
ตั้งแต่ C ++ 11 เป็นต้นไปวัตถุจะมีฟังก์ชันสมาชิกพิเศษเพิ่มอีก 2 ฟังก์ชันคือตัวสร้างการย้ายและการกำหนดย้าย กฎของห้ารัฐเพื่อใช้ฟังก์ชันเหล่านี้เช่นกัน
ตัวอย่างที่มีลายเซ็นต์:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age); // Ctor
person(const person &) = default; // Copy Ctor
person(person &&) noexcept = default; // Move Ctor
person& operator=(const person &) = default; // Copy Assignment
person& operator=(person &&) noexcept = default; // Move Assignment
~person() noexcept = default; // Dtor
};
กฎของศูนย์
กฎ 3/5 ยังถูกอ้างถึงเป็นกฎของ 3/3/5 ส่วนที่เป็นศูนย์ของกฎระบุว่าคุณได้รับอนุญาตให้ไม่เขียนฟังก์ชันสมาชิกพิเศษใด ๆ เมื่อสร้างคลาสของคุณ
คำแนะนำ
ส่วนใหญ่คุณไม่จำเป็นต้องจัดการทรัพยากรด้วยตัวเองเพราะคลาสที่มีอยู่แล้วเช่นนั้นstd::stringมีไว้สำหรับคุณแล้ว เพียงเปรียบเทียบรหัสอย่างง่ายโดยใช้std::stringสมาชิกกับทางเลือกที่ซับซ้อนและผิดพลาดโดยใช้ a char*และคุณควรมั่นใจ ตราบใดที่คุณอยู่ห่างจากสมาชิกตัวชี้แบบดิบกฎสามข้อนั้นไม่น่าจะเกี่ยวกับรหัสของคุณเอง
c++-faqก่อนที่คุณจะลงคะแนนใกล้