इसलिए, आपने C ++ में क्लास ऑब्जेक्ट को कॉपी करने का निर्णय लिया

अक्सर आप C ++ कोड पा सकते हैं जिसमें एक या एक से अधिक वर्गों के पास कॉपी कंस्ट्रक्टर और असाइनमेंट ऑपरेटर निजी घोषित किए जाते हैं और फॉर्म की एक टिप्पणी लिखते हैं "कॉपी करना निषिद्ध है"।

विधि सरल और स्पष्ट रूप से स्पष्ट है, हालांकि, इसका उपयोग करते समय, नुकसान संभव है, उन त्रुटियों के लिए अग्रणी जो जल्द ही दिखाई नहीं देंगे और जिनमें से खोज में एक दिन से अधिक समय लग सकता है।

संभावित समस्याओं पर विचार करें।

सबसे पहले, एक संक्षिप्त विषयांतर, इस तकनीक की आवश्यकता क्यों है।

यदि कोई प्रोग्राम किसी क्लास ऑब्जेक्ट को कॉपी करने की कोशिश करता है, तो C ++ कंपाइलर स्वचालित रूप से एक कॉपी कंस्ट्रक्टर या असाइनमेंट ऑपरेटर को डिफ़ॉल्ट रूप से जेनरेट करता है यदि वे स्पष्ट रूप से क्लास में घोषित नहीं किए जाते हैं। स्वचालित रूप से जेनरेट किया गया कंस्ट्रक्टर टर्म-बाय-टर्म कॉपी करता है, और एक ऑटोमैटिकली जेनरेट किया गया ऑपरेटर टर्म-बाय-टर्म असाइनमेंट करता है।

यहाँ एक सरल उदाहरण है:

class DoubleDelete { public: DoubleDelete() { ptr = new char[100]; } ~DoubleDelete() { delete[] ptr; } private: char* ptr; }; 

इस कोड में:

 { DoubleDelete first; DoubleDelete second( first ); } 

अपरिभाषित व्यवहार होगा। कंपाइलर द्वारा बनाई गई कॉपी कंस्ट्रक्टर को कहा जाएगा, जो पॉइंटर को कॉपी करेगा। नतीजतन, दोनों ऑब्जेक्ट समान पते वाले पॉइंटर्स को स्टोर करेंगे। पहली दूसरी वस्तु के विध्वंसक को अंजाम देने के लिए, यह डिलीट को अंजाम देगा [], फिर पहली वस्तु के डिस्ट्रक्टर को बुलाया जाएगा, यह उसी पते के लिए फिर से डिलीट करने की कोशिश करेगा [] और इससे अनिश्चित व्यवहार होगा।

समाधान स्पष्ट प्रतीत होता है - कॉपी कंस्ट्रक्टर और असाइनमेंट ऑपरेटर को सही व्यवहार के साथ लागू करने के लिए। उदाहरण के लिए, कॉपी करते समय, एक नई वस्तु अपना व्यूह बनाती है और पुराने में से डेटा कॉपी करती है।

यह हमेशा सही तरीका नहीं है। सभी ऑब्जेक्ट स्वाभाविक रूप से कॉपी करने योग्य नहीं होते हैं।

उदाहरण के लिए, एक ऑब्जेक्ट एक पूर्ण फ़ाइल डिस्क्रिप्टर को पूर्णांक के रूप में संग्रहीत कर सकता है। विध्वंसक ऑपरेटिंग सिस्टम फ़ंक्शन का उपयोग करके "फ़ाइल को बंद कर देता है"। जाहिर है, शब्द-आधारित प्रतिलिपि उपयुक्त नहीं है। और नकल करते समय क्या होना चाहिए? क्या फाइल फिर से खुलनी चाहिए? आमतौर पर इस मामले में, नकल का कोई मतलब नहीं है।

एक अन्य उदाहरण इस तरह के वर्ग की एक वस्तु बनाते समय एक महत्वपूर्ण खंड पर कब्जा करने के लिए एक वर्ग है। किसी वस्तु की नकल करने की बात क्या है? अनुभाग पहले से ही कैप्चर किया गया है।

इस पर एक संक्षिप्त विषयांतर समाप्त हो गया है, हम एक समाधान को चित्रित करने के प्रयास में बदल जाते हैं।

यदि किसी ऑब्जेक्ट को कॉपी करने का कोई मतलब नहीं है, तो आपको यह सुनिश्चित करने की आवश्यकता है कि संकलक गलती से इसे निष्पादित नहीं कर सकता है। ऐसा करने के लिए, वे आमतौर पर ऐसा करते हैं:

 // NOT BAD class NonCopyable { // blahblahblahpublic: private: // copy and assignment prohibited NonCopyable( const NonCopyable& ); void NonCopyable::operator=( const NonCopyable& ); }; 

या तो:

 // FAIL class NonCopyable { // blahblahblahpublic: private: // copy and assignment prohibited NonCopyable( const NonCopyable& ) { assert( false ); } void NonCopyable::operator=( const NonCopyable& ) { assert( false ); } }; 

या तो:

 // EPIC FAIL class NonCopyable { // blahblahblahpublic: private: // copy and assignment prohibited NonCopyable( const NonCopyable& ) {} void NonCopyable::operator=( const NonCopyable& ) {} }; 

तीनों विधियाँ वास्तविक कोड में पाई जाती हैं।

ऐसा लगता है, दूसरे और तीसरे विकल्प पहले से अलग कैसे हैं? किसी भी स्थिति में, निजी संशोधक कॉपी करने की अनुमति नहीं देगा।

अत्यधिक अनपेक्षित ...

एक ही वर्ग के सदस्य कार्य कॉपी कंस्ट्रक्टर और असाइनमेंट ऑपरेटर को कॉल कर सकते हैं, भले ही वे निजी घोषित किए गए हों। और वर्ग (दोस्त) के "दोस्त" भी हो सकते हैं। कोड में कुछ इस तरह लिखने की जहमत कोई नहीं उठाता:

 NonCopyable NonCopyable::SomeMethod() { // blahblahblah return *this; } 

या ऐसे:

 void NonCopyable::SomeOtherMehod() { callSomething( *this ); } 

अब पहले विकल्प और बाकी के बीच अंतर है।

पहला विकल्प (कोई कार्यान्वयन नहीं) कार्यक्रम को लिंक करते समय त्रुटि का कारण होगा। त्रुटि संदेश सबसे अधिक समझने योग्य नहीं है, लेकिन कम से कम विश्वसनीय है।

दूसरे संस्करण में, मुखर काम करेगा ... बशर्ते कि नियंत्रण इस कोड से गुजरता है। यहां बहुत कुछ इस बात पर निर्भर करता है कि इस कोड को कितनी बार कहा जाता है, विशेष रूप से, परीक्षणों के साथ कोड की कवरेज पर। हो सकता है कि आपको पहली बार में कोई समस्या दिखे, शायद बहुत जल्द।

तीसरा विकल्प और भी बेहतर है - असाइनमेंट ऑपरेटर ऑब्जेक्ट को नहीं बदलता है, और कॉपी कंस्ट्रक्टर क्लास के सभी सदस्यों के डिफॉल्ट कंस्ट्रक्टर को कॉल करता है। त्रुटियों के लिए व्यापक गुंजाइश, दूसरे की तुलना में नोटिस करना और भी मुश्किल हो सकता है।

अपेक्षित आपत्ति यह है कि चूंकि कॉपी कंस्ट्रक्टर और असाइनमेंट ऑपरेटर घोषित किए गए हैं, लेकिन परिभाषित नहीं हैं, उन्हें गलती से या दुर्भावनापूर्ण रूप से कोड में कहीं भी निर्धारित किया जा सकता है। यह समस्या बहुत सरलता से हल हो गई है।

"निषिद्ध परिचालनों" के प्रकार की टिप्पणी या, यदि संदेह में, "बर्खास्तगी के दर्द के तहत निषिद्ध संचालन निर्धारित नहीं किया जाना चाहिए" एक त्रुटि से मदद करता है। दुर्भावनापूर्ण इरादे से कुछ भी मदद नहीं करेगा - सी ++ में कोई भी किसी वस्तु का पता लेने के लिए परेशान नहीं करता है, इसे चार * प्रकार के लिए डाले, और बाइट द्वारा वस्तु को फिर से लिखें जैसा आप चाहें।

C ++ 0x में डिलीट कीवर्ड है:

 // C++0x OPTIMAL class NonCopyable { private: // copy and assignment not allowed NonCopyable( const NonCopyable& ) = delete; void operator=( const NonCopyable& ) = delete; // superior developers wanted – www.abbyy.ru/vacancy }; 

इस मामले में, यह न केवल निर्धारित करना असंभव होगा, बल्कि उन्हें कॉल करने के लिए भी होगा - जब आप कॉल के स्थान को संकलित करने का प्रयास करते हैं, तो एक संकलन त्रुटि जारी की जाएगी।

विकल्प "घोषित और परिभाषित नहीं" C ++ 0x से पहले उपलब्ध है, यह, विशेष रूप से, बढ़ावा देता है :: noncopyable। बूस्ट से प्राप्त करने का विकल्प :: noncopyable या समान वर्ग भी काफी विश्वसनीय है और किसी भी संस्करण में उपलब्ध है।

चौकस पाठक ने देखा होगा कि उपरोक्त सभी उदाहरणों में, असाइनमेंट ऑपरेटर शून्य देता है, और उसी वर्ग का संदर्भ नहीं। इसे खासतौर पर लुक को डिजाइन करने के लिए बनाया गया है

 first = second = third; 

C ++ 03 में संकलन त्रुटि हुई।

इसलिए छोटे कोड सुधार कभी-कभी डार्विन पुरस्कार से बचने में मदद करते हैं।

दिमित्री मेश्चेरीकोव,
डेवलपर उत्पाद विभाग