क्या प्रारंभिक सूची में निजी फ़ंक्शंस कॉल के मामले में यह अनिर्धारित व्यवहार है?

Question

निम्नलिखित कोड पर विचार करें:

struct Calc 
{ 
    Calc(const Arg1 & arg1, const Arg2 & arg2, /* */ const ArgN & argn) : 
     arg1(arg1), arg2(arg2), /* */ argn(argn), 
     coef1(get_coef1()), coef2(get_coef2()) 
    { 
    } 

    int Calc1(); 
    int Calc2(); 
    int Calc3(); 

private: 
    const Arg1 & arg1; 
    const Arg2 & arg2; 
    // ... 
    const ArgN & argn; 

    const int coef1; // I want to use const because 
    const int coef2; //  no modification is needed. 

    int get_coef1() const { 
    // calc coef1 using arg1, arg2, ..., argn; 
    // undefined behavior?  
    } 
    int get_coef2() const { 
    // calc coef2 using arg1, arg2, ..., argn and coef1; 
    // undefined behavior? 
    } 

}; 

struct Calc पूरी तरह से परिभाषित नहीं है जब मैं get_coef1 फोन और get_coef2 इस कोड को मान्य है? क्या मुझे यूबी मिल सकती है?

Answer 1

12.6.2.8: सदस्य कार्य (आभासी सदस्य कार्यों सहित, 10.3) निर्माण के तहत किसी वस्तु के लिए बुलाया जा सकता है। इसी तरह, निर्माण के तहत एक वस्तु टाइपिड ऑपरेटर (5.2.8) या गतिशील_कास्ट (5.2.7) का संचालन हो सकती है। हालांकि, यदि इन परिचालनों को सीटीओ-प्रारंभिक (या सीटीओ-प्रारंभिक रूप से सीधे या अप्रत्यक्ष रूप से बुलाए गए फ़ंक्शन में) में किया जाता है, तो आधार कक्षाओं के लिए सभी ज्ञापन प्रारंभकर्ता पूर्ण हो चुके हैं, ऑपरेशन का परिणाम अनिर्धारित है।

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

Answer 2

चूंकि आपकी गणना पर निर्भर होने वाले चर पहले से ही कॉल के समय शुरू हो चुके हैं, यह अपरिभाषित व्यवहार नहीं होना चाहिए। संबंधित जानकारी के लिए this प्रश्न देखें।

Answer 3

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

struct Foo 
{ 
    int a, b; 
    int c; 
    Foo(): c(1), a(1), b(1) {} 
}; 

कि निर्माता में, चर आदेश में initialised कर रहे हैं क, ख, ग तो, सूची में क्रम में कुछ भी नहीं मतलब है। इसलिए यदि b और c पर कुछ गणना का उपयोग करके a का मूल्य प्रारंभ करना चाहते हैं तो आपको a की b और c के बाद किसी बिंदु पर a की घोषणा को स्थानांतरित करने की आवश्यकता होगी।