जब बेस क्लास से विरासत मिलती है, तो नेस्टेड कक्षाओं के साथ क्या होता है?</p> <pre><code>class Base { public: class Foo { ... }; ... }; </code></pre> <p>फिर एक और वर्ग के आधार से निकला है:

Question

मैं इन कक्षाओं है कहो

class Derived : public Base 
{ 
    // no mention or redefinition of nested class "Foo" anywhere in "Derived" 
}; 

इसका मतलब हम अब एक अलग Derived::Foo है, या Derived::FooBase::Foo के रूप में ठीक उसी है?

यहां इस परिदृश्य पर एक मोड़ है: क्या होगा अगर कोई Derived::Foo का उदाहरण फेंकता है? यह इस परिदृश्य में पकड़ा किया जाएगा:

catch (const Base::Foo &ex) 
{ 
    // would this also catch an instance of Derived::Foo? 
} 

Answer 1

Base::Foo और Derived::Foo वास्तव में एक ही प्रकार कर रहे हैं, एक वर्ग सिर्फ एक यौगिक प्रकार (draft C++ standard अनुभाग 3.9.2 से) है और हम एक प्रकार एक आधार से विरासत में मिली अपेक्षा नहीं व्युत्पन्न कक्षा में एक अलग प्रकार के वर्ग के लिए। उदाहरण के लिए यदि Base निहित:

typedef int newType1 ; 

रूप में लंबे समय DerivednewType1 redeclare नहीं किया तो हम Base::newType1 और Derived::newType1 ही प्रकार और एक नेस्टेड वर्ग अलग नहीं है होने की अपेक्षा करेंगे। अगर हम मसौदा मानक अनुभाग के लिए 9.2कक्षा सदस्यों पैरा उल्लेख कहते हैं (जोर मेरा):

[...] एक वर्ग के सदस्य डेटा सदस्यों, सदस्य कार्य हैं (9.3), नेस्टेड प्रकार, और गणक। डेटा सदस्य और सदस्य कार्य स्थिर या गैर स्थैतिक हैं; 9.4 देखें। नेस्टेड प्रकार कक्षाएं (9.1, 9.7) और कक्षाओं में परिभाषित गणना (7.2) हैं, और टाइपिफ घोषणा (7.1.3) के उपयोग से सदस्यों के रूप में घोषित मनमानी प्रकार हैं।

कि अंतर्ज्ञान की पुष्टि करता है कि नेस्टेड कक्षाएं सिर्फ प्रकार (और भी सदस्य), पूर्णता खातिर अनुभाग 9.7 ऊपर संदर्भित के लिए नेस्टेड वर्ग अनुभाग और अनुभाग 10 से हैं है व्युत्पन्न वर्गों पैरा हम देखते हैं:

[...] जब तक व्युत्पन्न वर्ग में redeclared, एक आधार वर्ग के सदस्य हैं भी [...]

व्युत्पन्न वर्ग के सदस्य माना जाता है। क्योंकि वे एक ही प्रकार पकड़ ठीक से काम करेंगे।

Answer 2

Derived::Foo सिर्फ Base::Foo तक पहुँच रहा है, इसलिए इन एक ही प्रकार का उल्लेख करने के लिए सिर्फ दो तरीके हैं। आप आसानी से std::is_same के साथ देख सकते हैं:

#include <type_traits> 

struct Base 
{ 
    class Foo {}; 
}; 

struct Derived : Base {}; 

static_assert(std::is_same< Base::Foo, Derived::Foo >::value, "Oops"); 

int main() 
{ 
    try { 
     throw Derived::Foo(); 
    } 
    catch(const Base::Foo&) {} 
} 

आप देख सकते हैं, यह भी एक नाम से फेंक और साथ ही अन्य कार्यों के द्वारा यह पकड़ने का मतलब है।

Live example