c++ - हरण - कोष्ठक चिन्ह के प्रकार




टाइप नाम के बाद कोष्ठक नए के साथ एक अंतर बनाते हैं? (4)

आइए पैडेंटिक पाएं, क्योंकि ऐसे मतभेद हैं जो वास्तव में आपके कोड के व्यवहार को प्रभावित कर सकते हैं। निम्नलिखित में से अधिकांश को "ओल्ड न्यू थिंग" आलेख में किए गए टिप्पणियों से लिया जाता है।

कभी-कभी नए ऑपरेटर द्वारा लौटाई गई स्मृति शुरू की जाएगी, और कभी-कभी यह इस बात पर निर्भर नहीं करेगा कि आप जिस प्रकार के नए हैं, वह एक पीओडी (सादा पुराना डेटा) है , या यदि यह एक वर्ग है जिसमें पीओडी सदस्य हैं और इसका उपयोग कर रहे हैं कंपाइलर से उत्पन्न डिफ़ॉल्ट कन्स्ट्रक्टर।

  • सी ++ 1998 में प्रारंभिकरण के 2 प्रकार हैं: शून्य और डिफ़ॉल्ट
  • सी ++ 2003 में एक तीसरी प्रकार की शुरुआत, मूल्य प्रारंभिक जोड़ा गया था।

मान लीजिये:

struct A { int m; }; // POD
struct B { ~B(); int m; }; // non-POD, compiler generated default ctor
struct C { C() : m() {}; ~C(); int m; }; // non-POD, default-initialising m

एक सी ++ 98 कंपाइलर में, निम्नलिखित होना चाहिए:

  • new A - अनिश्चित मूल्य
  • new A() - शून्य-प्रारंभिक

  • new B - डिफ़ॉल्ट निर्माण (बी :: एम अनियमित है)

  • new B() - डिफ़ॉल्ट निर्माण (बी :: एम अनियमित है)

  • new C - डिफ़ॉल्ट निर्माण (सी :: एम शून्य-प्रारंभिक है)

  • new C() - डिफ़ॉल्ट निर्माण (सी :: एम शून्य-प्रारंभिक है)

एक सी ++ 03 अनुरूप कंपेलर में, चीजों को इस तरह काम करना चाहिए:

  • new A - अनिश्चित मूल्य
  • new A() - मूल्य-प्रारंभिक ए, जो शून्य-प्रारंभिक है क्योंकि यह एक पीओडी है।

  • new B - डिफ़ॉल्ट-प्रारंभ होता है (पत्तियां बी :: एम अनियमित)

  • new B() - मूल्य-बी को प्रारंभ करता है जो सभी फ़ील्ड को शून्य-प्रारंभ करता है क्योंकि इसके डिफ़ॉल्ट सीटीआर उपयोगकर्ता द्वारा परिभाषित किए गए संकलक के रूप में संकलित होता है।

  • new C - डिफ़ॉल्ट-सी प्रारंभ करता है, जो डिफ़ॉल्ट ctor को कॉल करता है।

  • new C() - मूल्य-प्रारंभिक सी, जो डिफ़ॉल्ट ctor को कॉल करता है।

तो सी ++ के सभी संस्करणों में new A और new A() बीच एक अंतर है क्योंकि ए एक पीओडी है।

और new B() के मामले में सी ++ 98 और सी ++ 03 के बीच व्यवहार में अंतर है।

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

यदि 'टेस्ट' एक साधारण वर्ग है, तो इसमें कोई अंतर है:

Test* test = new Test;

तथा

Test* test = new Test();

आम तौर पर हमारे पास पहले मामले में डिफ़ॉल्ट-प्रारंभिकरण और दूसरे मामले में मूल्य-प्रारंभिकरण होता है।

उदाहरण के लिए: int (पीओडी प्रकार) के मामले में:

  • int* test = new int - हमारे पास कोई भी प्रारंभिकरण और मान * परीक्षण हो सकता है।

  • int* test = new int() - * परीक्षण में 0 मान होगा।

अगला व्यवहार आपके प्रकार के टेस्ट से निर्भर है। हमारे पास अव्यवस्थित मामले हैं: टेस्ट में डिफॉल्ट कन्स्ट्रक्टर है, टेस्ट ने डिफॉल्ट कन्स्ट्रक्टर जेनरेट किया है, टेस्ट में पीओडी सदस्य, गैर पीओडी सदस्य शामिल हैं ...


यह मानते हुए कि टेस्ट एक परिभाषित कन्स्ट्रक्टर के साथ एक वर्ग है, इसमें कोई फर्क नहीं पड़ता है। उत्तरार्द्ध रूप यह थोड़ा स्पष्ट बनाता है कि टेस्ट का कन्स्ट्रक्टर चल रहा है, लेकिन यह इसके बारे में है।


new Thing(); यह स्पष्ट है कि आप एक कन्स्ट्रक्टर चाहते हैं जबकि new Thing; यह समझने के लिए लिया जाता है कि अगर आपको कन्स्ट्रक्टर नहीं कहा जाता है तो आपको कोई फर्क नहीं पड़ता।

यदि उपयोगकर्ता द्वारा परिभाषित कन्स्ट्रक्टर के साथ संरचना / कक्षा पर उपयोग किया जाता है, तो कोई फर्क नहीं पड़ता। यदि एक छोटी संरचना / कक्षा (जैसे struct Thing { int i; }; ) पर बुलाया जाता है तो फिर new Thing; malloc(sizeof(Thing)); की तरह है malloc(sizeof(Thing)); जबकि new Thing(); calloc(sizeof(Thing)); की तरह है calloc(sizeof(Thing)); - यह शून्य शुरू हो जाता है।

गेटचा बीच में है:

struct Thingy {
  ~Thingy(); // No-longer a trivial class
  virtual WaxOn();
  int i;
};

new Thingy; का व्यवहार new Thingy; बनाम new Thingy(); इस मामले में सी ++ 98 और सी ++ 2003 के बीच बदल गया। कैसे और क्यों के लिए माइकल बुर के स्पष्टीकरण देखें।







c++-faq