C ++ स्ट्रक्चर्स को इनिशियलाइज़ करने का उचित तरीका

Question 1

हमारे कोड में एक POD (Plain Old Datastructure) संरचना शामिल है (यह एक बुनियादी c ++ संरचना है जिसमें अन्य संरचनाएं और POD चर हैं जिन्हें शुरुआत में आरंभ करने की आवश्यकता है।)

मैंने जो पढ़ा है , उसके आधार पर ऐसा लगता है कि:

myStruct = (MyStruct*)calloc(1, sizeof(MyStruct));

सभी मानों को शून्य से आरंभ करना चाहिए, जैसा कि निम्नानुसार है:

myStruct = new MyStruct();

हालांकि, जब दूसरे तरीके से संरचना को शुरू किया जाता है, तो Valgrind बाद में "सशर्त कूद या चाल की पुष्टि करता है, जो कि उन चरों का उपयोग किए जाने पर असमान मूल्य पर निर्भर करता है।" क्या मेरी समझ यहाँ त्रुटिपूर्ण है, या वाल्ग्रिंड झूठी सकारात्मकता फेंक रहा है?

Question 2

सी ++ में कक्षाएं / संरचनाएं समान हैं (प्रारंभिक के संदर्भ में)।

एक गैर POD संरचना में एक निर्माता हो सकता है इसलिए यह सदस्यों को आरंभ कर सकता है।
यदि आपकी संरचना एक POD है तो आप एक इनिलाइज़र का उपयोग कर सकते हैं।

struct C
{
    int x; 
    int y;
};

C  c = {0}; // Zero initialize POD

वैकल्पिक रूप से आप डिफ़ॉल्ट कंस्ट्रक्टर का उपयोग कर सकते हैं।

C  c = C();      // Zero initialize using default constructor
C  c{};          // Latest versions accept this syntax.
C* c = new C();  // Zero initialize a dynamically allocated object.

// Note the difference between the above and the initialize version of the constructor.
// Note: All above comments apply to POD structures.
C  c;            // members are random
C* c = new C;    // members are random (more officially undefined).

मेरा मानना है कि वैलग्राइंड को शिकायत है क्योंकि सी ++ काम कैसे करता था। (जब सी ++ को जीरो इनिशियलाइज़ेशन डिफॉल्ट कंस्ट्रक्शन के साथ अपग्रेड किया गया था) मुझे बिलकुल यकीन नहीं है। आपका सबसे अच्छा शर्त एक निर्माता को जोड़ना है जो ऑब्जेक्ट को इनिशियलाइज़ करता है (स्ट्रक्चर को अनुमति दी जाती है)।

एक साइड नोट के रूप में:
बहुत से शुरुआती लोग init को महत्व देते हैं:

C c(); // Unfortunately this is not a variable declaration.
C c{}; // This syntax was added to overcome this confusion.

// The correct way to do this is:
C c = C();

"मोस्ट वैक्सिंग पार्स" के लिए एक त्वरित खोज, मैं जितना कर सकता हूं उससे बेहतर स्पष्टीकरण प्रदान करेगा।

Question 3

आपने हमें जो बताया है, उससे यह वैलेग्रिड में एक झूठी सकारात्मकता प्रतीत होती है। के newसाथ वाक्य रचना() वस्तु मूल्य आरंभ कर देना चाहिए, यह मानते हुए यह पॉड है।

क्या यह संभव है कि आपकी संरचना के कुछ सबपार्टर वास्तव में POD नहीं हैं और यह अपेक्षित आरंभ को रोक रहा है? क्या आप अपने कोड को एक पोस्ट करने योग्य उदाहरण में सरल बनाने में सक्षम हैं जो अभी भी वैध त्रुटि को चिह्नित करता है?

वैकल्पिक रूप से शायद आपका कंपाइलर वास्तव में POD स्ट्रक्चर्स को महत्व नहीं देता है।

किसी भी मामले में संभवत: सबसे सरल समाधान है कंस्ट्रक्टर (ओं) को लिखना, जैसा कि संरचना / उपप्रकारों के लिए आवश्यक है।

Question 4

मैं कुछ परीक्षण कोड लिखता हूं:

#include <string>
#include <iostream>
#include <stdio.h>

using namespace std;

struct sc {
    int x;
    string y;
    int* z;
};

int main(int argc, char** argv)
{
   int* r = new int[128];
   for(int i = 0; i < 128; i++ ) {
        r[i] = i+32;
   }
   cout << r[100] << endl;
   delete r;

   sc* a = new sc;
   sc* aa = new sc[2];
   sc* b = new sc();
   sc* ba = new sc[2]();

   cout << "az:" << a->z << endl;
   cout << "bz:" << b->z << endl;
   cout << "a:" << a->x << " y" << a->y << "end" << endl;
   cout << "b:" << b->x << " y" << b->y <<  "end" <<endl;
   cout << "aa:" << aa->x << " y" << aa->y <<  "end" <<endl;
   cout << "ba:" << ba->x << " y" << ba->y <<  "end" <<endl;
}

जी ++ संकलित करें और चलाएं:

./a.out 
132
az:0x2b0000002a
bz:0
a:854191480 yend
b:0 yend
aa:854190968 yend
ba:0 yend

Question 5

आपको अपनी संरचना में जो भी सदस्य हैं, उन्हें आरंभ करने की आवश्यकता है, जैसे:

struct MyStruct {
  private:
    int someInt_;
    float someFloat_;

  public:
    MyStruct(): someInt_(0), someFloat_(1.0) {} // Initializer list will set appropriate values

};

Question 6

चूँकि यह एक POD संरचना है, आप इसे हमेशा 0 पर ही रद्द कर सकते हैं - यह आरंभिक क्षेत्रों को प्राप्त करने का सबसे आसान तरीका हो सकता है (यह मानते हुए कि यह उपयुक्त है)।

Question 7

यह मुझे सबसे आसान तरीका लगता है। संरचना सदस्यों को घुंघराले ब्रेसिज़ '{}' का उपयोग करके आरंभ किया जा सकता है। उदाहरण के लिए, निम्नलिखित एक मान्य प्रारंभ है।

struct Point 
{ 
   int x, y; 
};  

int main() 
{ 
   // A valid initialization. member x gets value 0 and y 
   // gets value 1.  The order of declaration is followed. 
   struct Point p1 = {0, 1};  
}

C ++ में स्ट्रक्चर्स के बारे में अच्छी जानकारी है - https://www.geeksforgeeks.org/structures-in-cpp/