परिचय
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
चूंकि हमने न तो खुद को कॉपी कंस्ट्रक्टर और न ही असाइनमेंट ऑपरेटर (न ही डिस्ट्रक्टर) के रूप में घोषित किया है, इसलिए ये हमारे लिए निहित हैं। मानक से उद्धरण:
[...] कॉपी कंस्ट्रक्टर और कॉपी असाइनमेंट ऑपरेटर, [...] और विध्वंसक विशेष सदस्य कार्य हैं। [ नोट : कार्यान्वयन कुछ वर्ग प्रकारों के लिए इन सदस्य कार्यों को स्पष्ट रूप से घोषित करेगा जब कार्यक्रम स्पष्ट रूप से उन्हें घोषित नहीं करता है।
यदि उनका उपयोग किया जाता है तो कार्यान्वयन उन्हें स्पष्ट रूप से परिभाषित करेगा। [...] अंतिम नोट ] [n3126.pdf अनुभाग 12 ]1]
डिफ़ॉल्ट रूप से, किसी ऑब्जेक्ट को कॉपी करने का अर्थ है उसके सदस्यों की प्रतिलिपि बनाना:
गैर-संघ श्रेणी X के लिए अनुमानित रूप से परिभाषित कॉपी कंस्ट्रक्टर अपने सब -जेक्ट्स की एक सदस्यवार कॉपी करता है। [n3126.pdf सेक्शन 12.8 316]
गैर-संघ श्रेणी X के लिए अनुमानित रूप से परिभाषित कॉपी असाइनमेंट ऑपरेटर अपने सबोबिज के सदस्यवार कॉपी असाइनमेंट करता है। [n3126.pdf सेक्शन 12.8 330]
निहित परिभाषाएँ
इस 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वस्तु मिलती है । अनुमानित रूप से परिभाषित विध्वंसक हमेशा खाली होता है। यह इस मामले में भी ठीक है क्योंकि हमने कंस्ट्रक्टर में कोई संसाधन हासिल नहीं किया था। personविध्वंसक समाप्त होने के बाद सदस्यों के विध्वंसक रूप से कहा जाता है:
विध्वंसक के शरीर को क्रियान्वित करने और शरीर के भीतर आवंटित किसी भी स्वचालित वस्तुओं को नष्ट करने के बाद, दसवीं कक्षा के लिए एक विध्वंसक एक्स के प्रत्यक्ष [...] सदस्यों के लिए विनाशकों को बुलाता है [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सदस्य की नकल करना एक पॉइंटर को कॉपी करता है, न कि कैरेक्टर एरे की ओर इशारा करता है! इसके कई अप्रिय प्रभाव हैं:
- के माध्यम से परिवर्तन
aदेखा जा सकता है b।
- एक बार
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 = xthis->namethat.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;
}
यह एक स्पष्ट जाँच के बिना स्व-असाइनमेंट का भी ध्यान रखता है। इस समस्या का एक और अधिक मजबूत समाधान प्रतिलिपि-और-स्व-मुहावरा है , लेकिन मैं यहां अपवाद सुरक्षा के विवरण में नहीं जाऊंगा। मैंने केवल निम्नलिखित बिंदु बनाने के लिए अपवादों का उल्लेख किया है: संसाधनों का प्रबंधन करने वाली कक्षाएं लिखना कठिन है।
गैर-संसाधन योग्य संसाधन
कुछ संसाधनों की प्रतिलिपि नहीं की जा सकती है या नहीं होनी चाहिए, जैसे फ़ाइल हैंडल या म्यूटेक्स। उस मामले में, बस 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;
तीन का नियम
कभी-कभी आपको एक संसाधन को प्रबंधित करने वाले वर्ग को लागू करने की आवश्यकता होती है। (कभी भी एक ही वर्ग में कई संसाधनों का प्रबंधन न करें, इससे केवल पीड़ा होगी।) उस स्थिति में, तीन का नियम याद रखें :
यदि आपको स्पष्ट रूप से विध्वंसक, कॉपी कंस्ट्रक्टर या कॉपी असाइनमेंट ऑपरेटर की स्पष्ट रूप से घोषणा करने की आवश्यकता है, तो आपको संभवतः उन तीनों को स्पष्ट रूप से घोषित करने की आवश्यकता है।
(दुर्भाग्य से, यह "नियम" 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 के नियम को 0/3/5 के नियम के रूप में भी जाना जाता है। नियम का शून्य भाग बताता है कि आपको अपनी कक्षा बनाते समय विशेष सदस्य कार्यों में से किसी को भी लिखने की अनुमति नहीं है।
सलाह
ज्यादातर समय, आपको स्वयं एक संसाधन का प्रबंधन करने की आवश्यकता नहीं है, क्योंकि एक मौजूदा वर्ग जैसे कि std::stringयह आपके लिए पहले से ही है। किसी std::stringसदस्य का उपयोग करके बस सरल कोड की तुलना करें और एक का उपयोग करके त्रुटि-प्रवण विकल्प का उपयोग करें char*और आपको आश्वस्त होना चाहिए। जब तक आप कच्चे पॉइंटर सदस्यों से दूर रहते हैं, तब तक तीन का नियम आपके अपने कोड की चिंता करने की संभावना नहीं है।
c++-faq।