एक संरचना के अंदर गतिशील स्मृति

Question

मैं कोड का एक टुकड़ा संपादित कर रहा हूं, जो एक बड़ी परियोजना का हिस्सा है, जो सरणी का एक समूह शुरू करने के लिए "कॉन्स्ट" का उपयोग करता है। क्योंकि मैं इन कॉन्स्टेस को पैरामीट्रिज़ करना चाहता हूं, मुझे स्मृति आवंटित करने के लिए "malloc" का उपयोग करने के लिए कोड को अनुकूलित करना होगा। दुर्भाग्य से structs के साथ एक समस्या है: मैं संरचना में गतिशील स्मृति आवंटित करने में सक्षम नहीं हूँ। इसे बाहर करने से मूल कोड में काफी संशोधन हो सकता है।

int globalx,globaly; 
struct bigStruct{ 
    struct subStruct{ 
      double info1; 
      double info2; 
      bool valid; 
    }; 
    double data; 

    //subStruct bar[globalx][globaly]; 
    subStruct ** bar=(subStruct**)malloc(globalx*sizeof(subStruct*)); 
    for(int i=0;i<globalx;i++) 
      bar[i]=(*subStruct)malloc(globaly*sizeof(subStruct)); 


}; 
int main(){ 
    globalx=2; 
    globaly=3; 
    bigStruct foo; 
    for(int i=0;i<globalx;i++) 
      for(int j=0;j<globaly;j++){ 
        foo.bar[i][j].info1=i+j; 
        foo.bar[i][j].info2=i*j; 
        foo.bar[i][j].valid=(i==j); 
      } 

    return 0; 
} 

नोट:: प्रोग्राम कोड में मैं संपादन कर रहा हूँ globalx और globaly थे स्थिरांक एक निर्धारित नाम स्थान में की

यहाँ एक छोटा सा उदाहरण है। अब मैंने "कॉन्स" हटा दिया है ताकि वे एक बार पैरामीटर के रूप में कार्य कर सकें जो एक बार सेट हो।

संक्षेप में: मैं संरचना के अंदर पदार्थ के लिए स्मृति को सही ढंग से आवंटित कैसे कर सकता हूं? बहुत बहुत धन्यवाद!

मैक्स

Answer 1

क्या यह सी या सी ++ कोड है। टैग सी ++ कहते हैं लेकिन कोड सी की तरह दिखता है। आप new के बजाय malloc का उपयोग क्यों कर रहे हैं?

अपने प्रश्न का उत्तर देने के लिए। संरचना को स्मृति को आवंटित करने के लिए एक निर्माता और इसे हटाने के लिए एक विनाशक दें।

याद रखें, सी ++ में कक्षाओं और structs के बीच एकमात्र अंतर यह है कि सदस्यों को डिफ़ॉल्ट रूप से एक वर्ग में और सार्वजनिक रूप से एक संरचना में निजी रूप से निजी होते हैं।

Answer 2

उपयोग कंस्ट्रक्टर्स (स्मृति आवंटन सहित) सभी प्रारंभ करने के लिए, और मुक्त स्मृति को विनाशकर्ता। और malloc का उपयोग न करें क्योंकि आपने C++ टैग के साथ अपना प्रश्न टैग किया है। malloc केवल स्मृति आवंटित करता है, यह वस्तुओं को प्रारंभ नहीं करेगा। निम्नलिखित नमूना दिखाता है कि यह सी ++:

struct bigStruct{ 
    struct subStruct{ 
      double info1; 
      double info2; 
      bool valid; 
    }; 

    // constructor 
    bigStruct(size_t num_of_subs) : bar(num_of_subs) 
    { 
    } 
    // destructor 
    ~bigStruct() 
    { 
    }   


protected: 
    double data;  
    std::vector<subStruct> bar; 
}; 

Answer 3

मुझे संदेह है कि आपको सी ++ के साथ थोड़ा सा अनुभव मिला है। तार्किक समाधान स्मृति को कन्स्ट्रक्टर में आवंटित करना है। यहां उस स्तर से सी ++ को पढ़ना शुरू करना जटिल होगा।

Answer 4

आप फ़ंक्शन प्रारंभिक_बिगस्ट्रक्चर() बना सकते हैं और बड़े स्ट्रक्चर की प्रत्येक परिभाषा के बाद इसका उपयोग कर सकते हैं। आपको सरल कोड/प्रतिस्थापन के साथ अपने कोड को संशोधित करने की आवश्यकता होगी।

सी में फ़ंक्शंस जोड़ने की अनुमति नहीं है, हालांकि यदि आप C++ का उपयोग पूरी तरह से एक अलग कहानी का उपयोग कर रहे हैं।

Answer 5

int globalx,globaly; 
typedef struct subStruct{ 
     double info1; 
     double info2; 
     char valid; 
}subStruct; 
struct bigStruct{ 
    struct subStruct ** bar; 
    double data; 
}; 
/*Don't bother sending gl.. var since they are global*/ 
void alloc_struct(struct bigStruct *foo) 
{ 
    int i; 
    foo->bar=(subStruct**)malloc(globalx*sizeof(subStruct*)); 
    for(i=0; i<globalx; i++) 
    { 
     foo->bar[i]=(subStruct*)malloc(globaly*sizeof(subStruct)); 
    } 
} 
int main(){ 
    int i,j; 
    globalx=2; 
    globaly=3; 
    struct bigStruct foo; 
    alloc_struct(&foo); 
    for(i=0;i<globalx;i++) 
      for(j=0;j<globaly;j++){ 
        foo.bar[i][j].info1=i+j; 
        foo.bar[i][j].info2=i*j; 
        foo.bar[i][j].valid=(i==j); 
      } 
    return 0; 
} 

सी में बस एक सुझाव है जहाँ आप जब से तुम नहीं कर सकते आप की तरह एक struc अंदर malloc का उपयोग जहां की कोशिश कर रहा एक समारोह कॉल करने के लिए की जरूरत है।