वर्चुअल फ़ंक्शन और पॉइंटर उपयोग को समझना

Question

स्लाइसिंग को समझने के बाद, जहां तक ​​मुझे लगता है कि इसे पॉइंटर्स का उपयोग गतिशील चर के लिए टूटा जा सकता है। लेकिन कैसे आते हैं? उस बिंदु पर कोई टुकड़ा क्यों नहीं है? मैं खुद को सोचता हूं लेकिन मुझे यकीन नहीं है। ppet = pdog; असाइनमेंट के बाद, पीडीओजी पेपेट के एक ही पते पर इंगित करता है। है ना?

//Program to illustrate use of a virtual function 
//to defeat the slicing problem. 

#include <string> 
#include <iostream> 
using namespace std; 

class Pet 
{ 
public: 
    virtual void print(); 
    string name;  
}; 

class Dog : public Pet 
{  
public: 
    virtual void print();//Keyword virtual not needed, but put 
         //here for clarity. (It is also good style!) 

string breed; 
}; 

int main() 
{ 
    Dog vdog; 
    Pet vpet; 

    vdog.name = "Tiny"; 
    vdog.breed = "Great Dane"; 
    vpet = vdog; 

    //vpet.breed; is illegal since class Pet has no member named breed 

    Dog *pdog; 
    pdog = new Dog; 
    pdog->name = "Tiny"; 
    pdog->breed = "Great Dane"; 

    Pet *ppet; 
    ppet = pdog; 
    ppet->print(); // These two print the same output: 
    pdog->print(); // name: Tiny breed: Great Dane 

    //The following, which accesses member variables directly 
    //rather than via virtual functions, would produce an error: 
    //cout << "name: " << ppet->name << " breed: " 
    //  << ppet->breed << endl; 
    //generates an error message: 'class Pet' has no member 
    //named 'breed' . 
    //See Pitfall section "Not Using Virtual Member Functions" 
    //for more discussion on this. 

    return 0; 
} 

void Dog::print() 
{ 
    cout << "name: " << name << endl; 
    cout << "breed: " << breed << endl; 
} 

void Pet::print() 

{ 
    cout << "name: " << endl;//Note no breed mentioned 
} 

आउटपुट:

The slicing problem: 
name: Tiny 
Note that it was print from Pet that was invoked. 
The slicing problem defeated: 
name: Tiny 
breed: Great Dane 
name: Tiny 
breed: Great Dane 

Answer 1

व्युत्पन्न कक्षाएं अनिवार्य रूप से अपने आधार वर्ग का एक उदाहरण, किसी भी अतिरिक्त फ़ील्ड व्युत्पन्न वर्ग कहते हैं के बाद से "शुरू"। तो:

class Base { 
    int a, b; 
}; 

class Derived { 
    int c, d; 
}; 

एक Derived उदाहरण स्मृति में इस तरह दिखता है:

[a] [b]|[c] [d] 

अब आप "टुकड़ा" यह एक Base उदाहरण में, यदि ऐसा होता है: वस्तुओं के लिए

[a] [b]|nothing 

प्वाइंटर दूसरी ओर हमेशा प्रकार के बावजूद एक ही आकार होता है, इसलिए एक पॉइंटर-टू-बेस व्युत्पन्न वस्तु को इंगित कर सकता है और कोई भी जानकारी खो नहीं सकता है। की शुरुआत Derived ऑब्जेक्ट का हिस्सा बिल्कुल Derived ऑब्जेक्ट के समान ही पता है।

Answer 2

जब आप कक्षा परिभाषित करते हैं, तो इसके सदस्य इसकी मेमोरी लेआउट को परिभाषित करते हैं। वर्ग डेटा सदस्यों को क्रमशः स्मृति में संग्रहीत किया जाता है।

जब आप कक्षाएं प्राप्त करते हैं और विरासत का उपयोग किया जाता है, तो व्युत्पन्न वर्ग के डेटा सदस्यों को बेस क्लास के बाद जोड़ा जाता है।

इस प्रकार, जब टुकड़ा होता है तो आप केवल बेस क्लास सदस्यों को "देख" प्रभावी ढंग से देख रहे हैं।

अब, सवाल "व्युत्पन्न वर्ग की क्यों संकेत ओटो आधार वर्ग टुकड़ा करने की क्रिया नहीं कर रहे हैं वस्तुओं" पर?

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

आगे पढ़ने के लिए शर्तों जाँच upcasting और downcasting।

उपक्रम एक व्युत्पन्न-श्रेणी संदर्भ या पॉइंटर को बेस-क्लास में परिवर्तित कर रहा है। दूसरे शब्दों में, उपक्रम हमें एक व्युत्पन्न प्रकार का इलाज करने की अनुमति देता है जैसे कि यह इसका मूल प्रकार था।

टिप्पणी अनुभाग से अपने प्रश्नों का उत्तर देने के लिए, "ओवरराइड क्या है?

एक आधार वर्ग से एक आभासी समारोह के रूप में एक ही नाम और प्रकार की एक समारोह पाने इसकी बुलाया अधिभावी।