क्या स्थिर क्षेत्र विरासत में मिले हैं?

Question

जब स्थैतिक सदस्यों को विरासत में मिलता है, तो क्या वे संपूर्ण पदानुक्रम के लिए स्थिर होते हैं, या सिर्फ उस वर्ग के लिए, यानी:

class SomeClass
{
public:
    SomeClass(){total++;}
    static int total;
};

class SomeDerivedClass: public SomeClass
{
public:
    SomeDerivedClass(){total++;}
};

int main()
{
    SomeClass A;
    SomeClass B;
    SomeDerivedClass C;
    return 0;
}

कुल तीन उदाहरणों में 3 होगा, या यह 2 के लिए SomeClassऔर 1 के लिए होगा SomeDerivedClass?

Answer 1

3 सभी मामलों में, क्योंकि static int totalविरासत में मिला SomeDerivedClassएक बिल्कुल SomeClassवैरिएबल नहीं है।

संपादित करें: वास्तव में 4 सभी मामलों में, जैसा कि @ejames ने देखा और अपने उत्तर में बताया, जो देखते हैं।

संपादित करें: दूसरे प्रश्न में कोड intदोनों मामलों में गायब है , लेकिन इसे जोड़ने से यह ठीक हो जाता है, अर्थात:

class A
{
public:
    static int MaxHP;
};
int A::MaxHP = 23;

class Cat: A
{
public:
    static const int MaxHP = 100;
};

ठीक काम करता है और ए :: मैक्सएचपी और कैट :: मैक्सएचपी के लिए अलग-अलग मूल्यों के साथ - इस मामले में उपवर्ग बेस क्लास से स्थैतिक "विरासत में नहीं" मिल रहा है, इसलिए, बोलने के लिए, इसे अपने स्वयं के बेनामी के साथ "छिपाना" है एक।

Comments

अच्छी व्याख्या, लेकिन संख्यात्मक उत्तर वास्तव में 4 है, 3 नहीं। मेरा जवाब देखें ( stackoverflow.com/questions/998247/… )

— e.James

+1, बहुत बढ़िया बिंदु, मैं आपको, धन्यवाद करने के लिए उत्तर का संपादन कर रहा हूँ!

— एलेक्स मार्टेली

+1, हालाँकि किसी को अधिक सही रूप से "+4 जो भी स्थिर सदस्य को आरंभीकृत है" कहना चाहिए। स्थिर सदस्य न तो स्थानीय गुंजाइश है और न ही नाम स्थान का दायरा है, इसलिए कहीं न कहीं एक परिभाषा होनी चाहिए जो एक मान प्रदान करती है ( जरूरी नहीं कि शून्य)। अन्यथा कोड एक-परिभाषा-नियम को पूरा नहीं करता है और संकलन नहीं करेगा।

— डेमन

लेकिन अगर static int totalप्रत्येक प्रत्येक वर्ग के लिए अलग-अलग होना चाहता है, तो प्रत्येक वर्ग को जोड़ने के static int totalलिए इसे प्राप्त करने का एकमात्र तरीका क्या है? या क्या केवल आधार वर्ग परिभाषा (?) का उपयोग करना संभव है, क्योंकि परिवर्तनशील totalहोना हर वर्ग की संपत्ति होनी चाहिए। दूसरी तरफ यह होना चाहिए static।

— LRDPRDX

Answer 2

उत्तर सभी मामलों में वास्तव में चार है, क्योंकि निर्माण के SomeDerivedClassकारण कुल दो बार वेतन वृद्धि होगी ।

यहाँ एक पूरा कार्यक्रम है (जिसका उपयोग मैंने अपने उत्तर को सत्यापित करने के लिए किया था):

#include <iostream>
#include <string>

using namespace std;

class SomeClass
{
    public:
        SomeClass() {total++;}
        static int total;
        void Print(string n) { cout << n << ".total = " << total << endl; }
};

int SomeClass::total = 0;

class SomeDerivedClass: public SomeClass
{
    public:
        SomeDerivedClass() {total++;}
};

int main(int argc, char ** argv)
{
    SomeClass A;
    SomeClass B;
    SomeDerivedClass C;

    A.Print("A");
    B.Print("B");
    C.Print("C");

    return 0;
}

और परिणाम:

A.total = 4
B.total = 4
C.total = 4

Answer 3

यह 4 है क्योंकि जब व्युत्पन्न वस्तु बनाई जाती है, तो व्युत्पन्न वर्ग निर्माता बेस क्लास कंस्ट्रक्टर को कॉल करता है।
तो स्थैतिक चर का मूल्य दो बार बढ़ जाता है।

Answer 4

#include<iostream>
using namespace std;

class A
{
public:
    A(){total++; cout << "A() total = "<< total << endl;}
    static int total;
};

int A::total = 0;

class B: public A
{
public:
    B(){total++; cout << "B() total = " << total << endl;}
};

int main()
{
    A a1;
    A a2;
    B b1;

    return 0;
}

यह होगा:

A() total = 1
A() total = 2
A() total = 3
B() total = 4

Answer 5

SomeClass () कंस्ट्रक्टर को स्वचालित रूप से कहा जा रहा है जब SomeDerivedClass () कहा जाता है, यह एक C ++ नियम है। यही कारण है कि कुल प्रत्येक SomeClass ऑब्जेक्ट के अनुसार एक बार बढ़ा हुआ है, और फिर SomeDerivedClass ऑब्जेक्ट के लिए दो बार। 2x1 + 2 = 4

Answer 6

3 तीनों उदाहरणों में।

और आपके अन्य प्रश्न के लिए, ऐसा लगता है कि आपको वास्तव में केवल स्थैतिक के बजाय एक कास्ट चर की आवश्यकता है। यह एक वर्चुअल फ़ंक्शन प्रदाता के लिए अधिक आत्म-व्याख्यात्मक हो सकता है जो आपको आवश्यक चर को लौटाता है जो व्युत्पन्न वर्गों में ओवरराइड होता है।

जब तक इस कोड को एक महत्वपूर्ण पथ में नहीं बुलाया जाता है जहां प्रदर्शन आवश्यक है, हमेशा अधिक सहज कोड के लिए विकल्प चुनें।

Answer 7

हां, व्युत्पन्न वर्ग में एक ही स्थिर चर होगा, अर्थात - वे सभी कुल 3 होंगे (यह मानते हुए कि कुल 0 से प्रारंभ किया गया था)।