[C ++] क्या हम नए और डिलीट ऑपरेटर्स के बारे में सब कुछ जानते हैं?

नमस्ते! नीचे हम नए और हटाए जाने वाले ऑपरेटरों के बारे में बात करेंगे जो सभी के लिए अच्छी तरह से ज्ञात हैं, और अधिक सटीक रूप से वे जो किताबों में नहीं लिखते हैं (कम से कम शुरुआती के लिए पुस्तकों में)।
इस लेख को लिखने के लिए, मुझे नई और हटाने के बारे में एक आम गलतफहमी से प्रेरित किया गया था, जिसे मैं कुछ पुस्तकों में मंचों और यहां तक ​​कि (!!!) पर लगातार देखता हूं।
क्या हम सभी जानते हैं कि नए और डिलीट क्या हैं ? या सिर्फ हमें लगता है कि हम जानते हैं?
यह लेख आपको यह पता लगाने में मदद करेगा (अच्छी तरह से, और जो लोग जानते हैं वे आलोचना कर सकते हैं :))

नोट : नीचे हम नए ऑपरेटर के बारे में विशेष रूप से बात करेंगे, नए ऑपरेटर के अन्य रूपों के लिए और डिलीट ऑपरेटर के सभी रूपों के लिए, नीचे का सभी भी सही है और सादृश्य द्वारा लागू होता है।

इसलिए, शुरू करने के लिए, आमतौर पर शुरुआती के लिए पुस्तकों में क्या लिखा जाता है जब वे नया वर्णन करते हैं (पाठ "छत से लिया जाता है", लेकिन सामान्य रूप से सत्य से मेल खाता है):

नया ऑपरेटर आवश्यक आकार से अधिक या उसके बराबर मेमोरी आवंटित करता है और, C भाषा फ़ंक्शन के विपरीत, ऑब्जेक्ट (ओं) के लिए निर्माता (ओं) को कॉल करता है, जिसके लिए मेमोरी आवंटित की जाती है ... आप अपनी आवश्यकताओं के अनुरूप नए ऑपरेटर को अधिभारित कर सकते हैं (वे कहीं और लागू करने के लिए लिखते हैं)।

और उदाहरण के लिए, वे नए ऑपरेटर के आदिम अधिभार (कार्यान्वयन) दिखाते हैं, जिसका प्रोटोटाइप इस तरह दिखता है
void* operator new (std::size_t size) throw (std::bad_alloc);

मैं किस पर ध्यान देना चाहता हूं:
1. कहीं भी वे C ++ भाषा के नए कुंजी-शब्द और नए ऑपरेटर को साझा नहीं करते हैं, हर जगह उन्हें एक इकाई के रूप में बोला जाता है।
2. हर जगह वे लिखते हैं कि नई वस्तु (ओं) के लिए निर्माता को बुलाता है।
पहले और दूसरे दोनों एक आम गलत धारणा है।

लेकिन हम शुरुआती के लिए पुस्तकों की उम्मीद नहीं करेंगे, हम मानक के लिए बदलेंगे, अर्थात् खंड 5.3.4 और 18.6.1 तक, जिसमें इस लेख का विषय वास्तव में पता चला है (या बल्कि खोला गया है)।

5.3.4
नए-एक्सप्रेशन प्रकार-आईडी (8.1) या नए-प्रकार-आईडी का एक ऑब्जेक्ट बनाने का प्रयास करते हैं, जिस पर इसे लागू किया जाता है। / * आगे हमें कोई दिलचस्पी नहीं है * /
18.6.1
शून्य * ऑपरेटर नया (std :: size_t size) फेंक (std :: bad_alloc);
प्रभाव: आकार बाइट्स को आवंटित करने के लिए एक नई-अभिव्यक्ति (5.3.4) द्वारा आवंटन फ़ंक्शन
भंडारण उस आकार की किसी भी वस्तु का प्रतिनिधित्व करने के लिए उपयुक्त रूप से संरेखित / * हम आगे रुचि नहीं हैं * / /

यहां हम पहले से ही देखते हैं कि पहले मामले में नए को अभिव्यक्ति के रूप में संदर्भित किया जाता है , और दूसरे में इसे ऑपरेटर के रूप में घोषित किया जाता है। और ये वास्तव में 2 अलग-अलग संस्थाएं हैं!
आइए यह पता लगाने की कोशिश करें कि ऐसा क्यों है, इसके लिए हमें नए का उपयोग करके कोड को संकलित करने के बाद प्राप्त कोडांतरक लिस्टिंग की आवश्यकता होगी । खैर, अब क्रम में सब कुछ के बारे में।

नई-अभिव्यक्ति एक भाषा कथन है, जैसे कि , जबकि , आदि। (यद्यपि यदि, जबकि , आदि को अभी भी कथन के रूप में संदर्भित किया जाता है , लेकिन गीत को छोड़ दें) इसे लिस्टिंग में मिलते हुए, कंपाइलर इस कथन के अनुरूप कुछ कोड उत्पन्न करता है। साथ ही नया C ++ भाषा के प्रमुख शब्दों में से एक है, जो एक बार फिर से अगर , जैसे, आदि के साथ अपनी समानता की पुष्टि करता है। और ऑपरेटर नया (), बदले में, केवल उसी नाम का एक C ++ भाषा फ़ंक्शन है, जिसके व्यवहार को फिर से परिभाषित किया जा सकता है। महत्वपूर्ण - ऑपरेटर नया () ऑब्जेक्ट के लिए कंस्ट्रक्टर (ओं) को कॉल नहीं करता है, जिसके तहत मेमोरी आवंटित की जाती है। यह सिर्फ सही आकार की मेमोरी को आवंटित करता है और यही है। फ़ंक्शन फ़ंक्शन से इसका अंतर यह है कि यह एक अपवाद को फेंक सकता है और ओवरराइड किया जा सकता है, साथ ही एक विशेष वर्ग के लिए एक ऑपरेटर बनाया जा सकता है, जिससे यह केवल इस वर्ग के लिए ओवरराइड कर सकता है (बाकी खुद को याद रखें :))।
लेकिन नई अभिव्यक्ति सिर्फ ऑब्जेक्ट (ओं) के निर्माता को बुलाती है। हालाँकि यह कहना अधिक सही है कि यह किसी भी चीज़ को कॉल नहीं करता है, बस इसे पूरा करने पर, कंपाइलर कंस्ट्रक्टर को कॉल करने के लिए एक कोड तैयार करता है।

चित्र को पूरा करने के लिए, निम्नलिखित उदाहरण पर विचार करें:

 #include <iostream> class Foo { public: Foo() { std::cout << "Foo()" << std::endl; } }; int main () { Foo *bar = new Foo; } 

इस कोड के निष्पादन के बाद, जैसा कि अपेक्षित है, "फू ()" मुद्रित किया जाएगा। आइए जानें कि इसके लिए आपको कोडांतरक पर ध्यान देने की आवश्यकता है, जिसकी मैंने सुविधा के लिए थोड़ी टिप्पणी की।
(कोड MSVS 2012 में उपयोग किए गए cl कंपाइलर द्वारा प्राप्त किया गया था, हालांकि मैं मुख्य रूप से gcc का उपयोग करता हूं, लेकिन यह लागू नहीं होता है)

 /Foo *bar = new Foo; push 1 ;      Foo call operator new (02013D4h) ;  operator new pop ecx mov dword ptr [ebp-0E0h],eax ;  ,   new,  bar and dword ptr [ebp-4],0 cmp dword ptr [ebp-0E0h],0 ;   0    bar je main+69h (0204990h) ;  0,    (   main   - ,    ) mov ecx,dword ptr [ebp-0E0h] ;       ecx (MSVS   this  ecx(rcx)) call Foo::Foo (02011DBh) ;    ;    

उन लोगों के लिए जो कुछ भी नहीं समझते हैं, यहां एक (लगभग) एनालॉग है जो एक घूंट की तरह छद्म कोड पर हुआ (यानी इस संकलन के लिए प्रयास न करें :))

 Foo *bar = operator new (1); //  1 -   bar->Foo(); //   

उपर्युक्त कोड ऊपर लिखे गए सब कुछ की पुष्टि करता है, अर्थात्:
1. (भाषा) ऑपरेटर नया और ऑपरेटर नया () एक ही बात नहीं है।
2. ऑपरेटर नया () निर्माणकर्ता को कॉल नहीं करता है
3. कंपाइलर कोड में कुंजी-शब्द "नया" को पूरा करते हुए, कंस्ट्रक्टर (ओं) को एक कॉल उत्पन्न करता है

नीचे पंक्ति: मुझे आशा है कि इस लेख ने आपको नई-अभिव्यक्ति और ऑपरेटर नए () के बीच के अंतर को समझने में मदद की या यह भी पता लगाया कि यह (यह अंतर) मौजूद है अगर कोई नहीं जानता था।

PS डिलीट ऑपरेटर और ऑपरेटर डिलीट () में समान अंतर है, इसलिए लेख की शुरुआत में मैंने कहा कि मैं इसका वर्णन नहीं करूंगा। मुझे लगता है कि अब आप समझ गए हैं कि इसका विवरण समझ में क्यों नहीं आता है और आप स्वतंत्र रूप से सत्यापित कर सकते हैं कि डिलीट के लिए ऊपर क्या लिखा गया था।

अपडेट:
व्यक्तिगत पत्राचार में उपनाम खीम के साथ ख्रजीतेल ने निम्नलिखित कोड का सुझाव दिया, जो उपरोक्त के सार को अच्छी तरह से प्रदर्शित करता है।

 #include <iostream> class Test { public: Test() { std::cout << "Test::Test()" << std::endl; } void* operator new (std::size_t size) throw (std::bad_alloc) { std::cout << "Test::operator new(" << size << ")" << std::endl; return ::operator new(size); } }; int main() { Test *t = new Test(); void *p = Test::operator new(100); // 100     } 

यह कोड निम्नलिखित आउटपुट देगा

 Test::operator new(1) Test::Test() Test::operator new(100) 

जिसकी उम्मीद की जानी है।