सी संरचनाओं को शुरू करते समय शब्दावली

Question

यह एक आसान सवाल होगा लेकिन आस-पास घूमने से मुझे जवाब नहीं मिल रहा है। जिस तरह से मैं इसे सी में समझता हूं, हमारे पास foo ऑब्जेक्ट को प्रारंभ करने के दो तरीके होते हैं, जब foo एक संरचना है। उदाहरण के लिए नीचे दिए गए कोड को देखें

typedef struct foo 
{ 
    int var1; 
    int var2; 
    char* var3; 
}foo; 

//initializes and allocates a foo 
foo* foo_init1(int v1,int v2,const char* v3) 
{ 
    if(..some checks..) 
     return 0; 
    foo* ret = malloc(sizeof(foo)); 

    ret->var1 = v1; 
    ret->var2 = v2; 
    ret-var3 = malloc(strlen(v3)+1); 
    strcpy(ret->var3,v3); 

    return ret; 
} 

// initializes foo by ... what? How do we call this method of initialization? 
char foo_init2(foo* ret,int v1,int v2, const char* v3) 
{ 
    //do some checks and return false 
    if(...some checks..) 
     return false//;assume you defined true and false in a header file as 1 and 0 respectively 
    ret->var1 = v1; 
    ret->var1 = v1; 
    ret->var2 = v2; 
    ret-var3 = malloc(strlen(v3)+1); 
    strcpy(ret->var3,v3); 

    return true; 
} 

तो मेरा प्रश्न यह है। हम सी को इन विभिन्न प्रारंभिक तरीकों से कैसे संदर्भित करते हैं? पहले एक initialized सूचक तो foo के लिए अगर आप इस तरह के ढेर पर एक foo वस्तु चाहते हैं उपयोग करने के लिए आसान है रिटर्न:

foo* f1 = foo_init1(10,20,"hello"); 

लेकिन दूसरे एक foo की आवश्यकता है .. क्या? नीचे दिए गए कोड को देखें।

foo f1; 
foo_init2(&f1,10,20,"hello"); 

तो दूसरी विधि स्टैक पर किसी ऑब्जेक्ट को प्रारंभ करना आसान बनाता है लेकिन आप इसे कैसे कॉल करते हैं? यह मूल रूप से मेरा प्रश्न है, प्रारंभिकरण की दूसरी विधि को कैसे संदर्भित किया जाए।

पहले एक आवंटित और फू के लिए सूचक initializes। दूसरा दूसरा एक foo शुरू करता है ... क्या? संदर्भ?

बोनस प्रश्न के रूप में, सी में कोडिंग करते समय आप लोग कैसे काम करते हैं? क्या आप उस ऑब्जेक्ट का उपयोग निर्धारित करते हैं जो आप बना रहे हैं और यह निर्धारित करते हैं कि क्या आपके पास टाइप 1, या 2 या यहां तक ​​कि दोनों का प्रारंभिक कार्य होना चाहिए?

Answer 1

टिप्पणियों में लोगों में से कोई भी के बाद से प्रस्ताव पर लिया एक जवाब मैं अपने ही सवाल का जवाब देने के लिए मजबूर कर रहा हूँ में उनकी टिप्पणी चालू करने के लिए।

खैर मूल रूप से एक संभावित जवाब हो सकता है कोई विशेष नामकरण परंपरा है कि वहाँ एआईएस के रूप में कहा गया है। बेशक जो कुछ भी नामकरण विधि का इस्तेमाल किया जाता है, यह होना चाहिए:

• अनुरूप परियोजना/एस के सभी भर में स्पष्टता की खातिर
• पहचानों के लिए एक समारोह है कि यह वास्तव क्या कर रहा है करता है के रूप में अन्य प्रोग्रामर द्वारा ।

प्राप्त करने के लिए टिप्पणी में कुछ महान सिफारिशों श्रेणियां थीं।जब एक foo वस्तु है के लिए:

• समारोह के अंदर प्रारंभ के लिए उत्तीर्ण: foo_init
• समारोह अंदर आवंटित और एक सूचक लौटे: foo_alloc, foo_make, foo_new

उपरोक्त सभी स्पष्ट हैं मुझे लगता है लेकिन क्या हो रहा है सबसे सटीक रूप से वर्णन करता है कार्यों में foo_init और foo_alloc होगा।

व्यक्तिगत रूप से मैं वास्तव में _alloc समाधान को नापसंद करता हूं क्योंकि मुझे यह पसंद नहीं है कि यह मेरे कोड में कैसा दिखता है, इसलिए मैंने यह कार्य करने के बाद फ़ंक्शन के बाद क्रिया को क्रियान्वित करने का निर्णय लिया है जो यह कर रहा है।

लेकिन मुझे लगता है कि उत्तर का अनुमान है कि मुझे लगता है कि व्यक्तिगत वरीयता है। सभी को ठीक और स्वीकार्य होना चाहिए जब तक कि कार्य की कार्यक्षमता अपना नाम पढ़कर स्पष्ट हो।

Answer 2

मैं अगर कोई अच्छी तरह से दो विधियों के लिए नामकरण परिभाषित कर रहे हैं यकीन नहीं है,
पहली विधि समारोह गतिशील रूप से एक संरचना आवंटित और सदस्यों को मान प्रदान करती है में,
दूसरे में संरचना से पहले आवंटित किया जाता है, जबकि फ़ंक्शन और फ़ंक्शन केवल सदस्यों को मान निर्दिष्ट करता है।

आप वस्तु आप कर रहे हैं और कहा कि निर्धारित करता है, तो आप type1 के आरंभ समारोह, या 2 या उनमें से भी दोनों होना चाहिए द्वारा की उपयोगिता का निर्धारण करते हैं?

का चयन पहली या दूसरी विधि एक महत्वपूर्ण अंतर पर निर्भर करता है:
पहली विधि पसंद किया जाता है जब आप कार्यक्षेत्र भर में लौटे संरचना पारित करने के लिए की जरूरत है, ढेर पर स्मृति स्पष्ट तक मुक्त होने के जो डेटा की तस है, जबकि है दूसरी विधि में पारित वस्तु के दायरे समाप्त होने के बाद स्टैक पर डेटा हटा दिया जाता है।