क्या खाली कक्षा के निर्माता को वास्तव में किसी भी स्मृति का उपयोग करना है?

Question

मान लीजिए मैं

class Empty{ 
    Empty(int a){ cout << a; } 
} 

की तरह एक वर्ग है और फिर मैं यह

int main(){ 
    Empty(2); 
    return 0; 
} 

का उपयोग कर लागू करेगा इस कारण किसी भी स्मृति एक "खाली" वस्तु के निर्माण के लिए ढेर पर आवंटित किया जाना? जाहिर है, तर्कों को ढेर पर धकेलने की जरूरत है, लेकिन मैं कोई अतिरिक्त ओवरहेड नहीं लेना चाहता हूं। असल में मैं एक स्थिर सदस्य के रूप में निर्माता का उपयोग कर रहा हूँ।

कारण मैं टेम्पलेट्स के कारण ऐसा करना चाहता हूं।

तरह

template <int which> 
class FuncName{ 
    template <class T> 
    FuncName(const T &value){ 
     if(which == 1){ 
      // specific behavior 
     }else if(which == 2){ 
      // other specific behavior 
     } 
    } 
}; 

जो मुझे,

int main(){ 
    int a = 1; 
    FuncName<1>(a); 
} 

ताकि मैं एक टेम्पलेट पैरामीटर विशेषज्ञ करने के लिए मिलता

की तरह कुछ लिखने के लिए है, जबकि T का प्रकार निर्दिष्ट करने नहीं होने की अनुमति देता है वास्तविक कोड लग रहा है। साथ ही, मुझे आशा है कि संकलक अन्य शाखाओं को कन्स्ट्रक्टर के अंदर दूर कर देगा। अगर कोई जानता है कि यह सच है या कैसे जांचें, तो इसकी सराहना की जाएगी। मैंने यह भी माना कि स्थिति में टेम्पलेट फेंकने से ऊपर से "खाली वर्ग" समस्या नहीं बदली है, क्या यह सही है?

Answer 1

Stroustrup का हवाला देते हुए:

एक खाली वर्ग के आकार क्यों शून्य नहीं है? यह सुनिश्चित करने के लिए कि दो अलग-अलग वस्तुओं के पते अलग होंगे। इसी कारण से, "नया" हमेशा विशिष्ट वस्तुओं को पॉइंटर्स देता है। पर विचार करें:

class Empty { }; 

void f() 
{ 
    Empty a, b; 
    if (&a == &b) cout << "impossible: report error to compiler supplier"; 

    Empty* p1 = new Empty; 
    Empty* p2 = new Empty; 
    if (p1 == p2) cout << "impossible: report error to compiler supplier"; 
} 

एक दिलचस्प शासन का कहना है कि एक खाली आधार वर्ग एक अलग बाइट द्वारा प्रतिनिधित्व करने की आवश्यकता नहीं है:

struct X : Empty { 
    int a; 
    // ... 
}; 

void f(X* p) 
{ 
    void* p1 = p; 
    void* p2 = &p->a; 
    if (p1 == p2) cout << "nice: good optimizer"; 
} 

यह अनुकूलन सुरक्षित है और सबसे अधिक उपयोगी हो सकता है। यह एक प्रोग्रामर को बिना खाली के बहुत सरल अवधारणाओं का प्रतिनिधित्व करने के लिए खाली कक्षाओं का उपयोग करने की अनुमति देता है। कुछ वर्तमान कंपाइलर इस "खाली बेस क्लास अनुकूलन" प्रदान करते हैं।

Answer 2

यह परिस्थितियों के आधार पर हो सकता है, ऐसा नहीं हो सकता है। यदि आप कहते हैं:

Empty e; 
Empty * ep = & e; 

तो स्पष्ट रूप से चीजों को आवंटित किया जाना चाहिए।

Answer 3

इसे आज़माएं और देखें। जब उनके आउटपुट को अनुकूलित करने के लिए कहा जाता है तो कई कंपाइलर्स ऐसी अस्थायी वस्तुओं को खत्म कर देंगे।

हैं disassembly बहुत जटिल है, तो इस तरह की वस्तुओं के विभिन्न संख्या के साथ दो कार्यों की तरह कुछ बना सकते हैं और अगर वहाँ उन्हें आसपास के वस्तुओं के ढेर स्थानों में कोई अंतर है देखते हैं,:

void empty1 (int x) 
{ 
    using namespace std; 

    int a; 
    Empty e1 (x); 
    int b; 

    cout << endl; 
    cout << "empty1" << endl; 
    cout << hex << int (&x) << " " << dec << (&x - &a) << endl; 
    cout << hex << int (&a) << " " << dec << (&a - &b) << endl; 
} 

और फिर कोशिश चल रहे आठ एम्प्टीज़ के साथ empty8 फ़ंक्शन की तुलना में चल रहा है। X86 पर g ++ के साथ, यदि आप किसी भी खाली खालीियों का पता लेते हैं तो आपको एक्स और ए के बीच एक स्थान मिलता है, इसलिए आउटपुट में एक्स भी शामिल है। आप यह नहीं मान सकते कि ऑब्जेक्ट्स के लिए स्टोरेज उसी क्रम में समाप्त हो जाएगा जैसा कि उन्हें स्रोत कोड में घोषित किया गया है।