सी ++ बेस क्लास इंस्टेंस

Question

से कॉल व्युत्पन्न फ़ंक्शन मैं सी ++ के लिए बिल्कुल नया हूं, लेकिन मैं एक ऐसे मुद्दे में भाग गया हूं जिसे मैं हल नहीं कर सकता। मैं चीजों को आसान बनाने के लिए समस्या का वर्णन करने के लिए कारों का उपयोग करूंगा। ठीक है तो मान लें कि मेरे पास बेस क्लास कार है, और मेरे पास अलग-अलग ब्रांड हैं जो उस वर्ग से विरासत में हैं। इस प्रकार:

class Car 
{ 
    public: 
     Car(); 
}; 

class Ford: public Car 
{ 
    public: 
     Ford(); 
     void drive(); 
     void park(); 
}; 

संपूर्ण विचार यह है कि इन सभी अलग-अलग कारों को एक प्रकार के कार के एक वेक्टर में एक साथ रखना है। इस तरह:

vector<Car*> cars; 
cars.push_back(new Ford()); 
cars.back()->drive(); //this won't work 

मैं बेस क्लास उदाहरण पर व्युत्पन्न फ़ंक्शन को कैसे कॉल कर सकता हूं? ध्यान दें कि मैं इन सभी को एक वेक्टर में रखना चाहता हूं। इसका कारण यह है कि मैं केवल अंतिम व्युत्पन्न कार वर्ग उदाहरण का उपयोग करना चाहता हूं जिसे जोड़ा गया है। (इस मामले में व्युत्पन्न कार वर्ग फोर्ड है)। यह भी ध्यान रखें कि सभी कार वर्गों में एक ही कार्य होगा।

Answer 1

यदि ये कार्य सभी व्युत्पन्न कक्षाओं के लिए वास्तव में आम हैं, तो आपके पास एक सामान्य इंटरफ़ेस है, इसलिए आपको इसे बेस क्लास के माध्यम से व्यक्त करना चाहिए। ऐसा करने के लिए, आप शुद्ध आभासी रूप में इन कार्यों की घोषणा:

class Car { 
public: 
    virtual void drive() = 0; // Pure-virtual function 
}; 

class Ford : public Car { 
public: 
    virtual void drive() { std::cout << "driving Ford\n"; } 
}; 

... 

vector<Car*> cars; 
cars.push_back(new Ford()); 
cars.back()->drive(); //this will work 

[एक तरफ ध्यान दें पर, यह आम तौर पर, गरीब अभ्यास माना जाता है कच्चे संकेत का एक वेक्टर है क्योंकि यह स्मृति प्रबंधन मुश्किल बना देता है। आपको स्मार्ट पॉइंटर्स का उपयोग करने पर विचार करना चाहिए।]

Answer 2

सभी Car कक्षाएं ही कार्य है, तो फिर उन्हें आधार वर्ग Car में शुद्ध रूप virtual घोषित:

class Car 
{ 
public: 
    Car(); 
    virtual ~Car(); 
    virtual void drive() = 0; 
    virtual void park() = 0; 
}; 

यह vector का उपयोग करता है पोस्ट के रूप में काम करने के लिए उदाहरण कोड की अनुमति देगा।

class Car{ 
public: 
Car(); 
virtual void moveForward(unsigned int speed) = 0; 
virtual void moveBack(unsigned int speed) = 0; 
//... 
virtual ~Car(); 
}; 

मत भूलना नाशक आभासी बनाने के लिए: यदि संभव हो तो आप के रूप में

class Car 
{ 
    public: 
     Car(); 
     virtual void drive(); 
}; 

Answer 3

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

Answer 4

आधार वर्ग को परिभाषित कर सकते

Answer 5

आपके पास दो विकल्प हैं: या तो अपनी कार परिभाषा में वर्चुअल ड्राइव() विधि डालें, या कार पॉइंटर्स को फोर्ड पॉइंटर्स पर डालें। संभावना है कि आप पहले करना चाहते हैं।

class Car 
{ 
    public: 
     Car(); 
     virtual void drive() { // default implementation} 
}; 

अब आप अपनी कार ड्राइव कर सकते हैं! तुम भी ड्राइव() एक शुद्ध आभासी समारोह कर सकते हैं, तो जैसे:

class Car 
{ 
    public: 
     Car(); 
     virtual void drive() = 0; 
}; 

यह मूलतः इसका मतलब ड्राइव() के लिए कोई डिफ़ॉल्ट कार्यान्वयन है कि वहाँ: यह एक उपवर्ग में reimplemented किया जाना चाहिए।

static_cast<Ford*>(cars.back())->drive(); 

यह केवल काम करता है अगर आप जानते हैं पहले से है कि कार एक फोर्ड है: मैंने दूसरी तरह से उल्लेख किया है, जो, फिर से, आप शायद नहीं चाहते हैं, लेकिन पूर्णता के लिए शामिल किया जाना चाहिए, सूचक कास्ट करने के लिए है हालांकि, और इस परिदृश्य में ज्यादा उपयोग नहीं है। आप गतिशील_कास्ट में भी देख सकते हैं।

Answer 6

आपको वर्चुअल फ़ंक्शन रखना होगा।

बेस क्लास में वर्चुअल फ़ंक्शन। उप वर्चुअल फ़ंक्शन को उप-वर्ग में कार्यान्वित किया जा सकता है, ताकि आप उदाहरण के लिए ड्राइव() के व्यवहार को विशेषज्ञ बना सकें।

आप एक सामान्य प्रश्न (या ट्यूटोरियल) यहाँ आभासी कार्यों के बारे में पा सकते हैं:

http://www.parashift.com/c++-faq-lite/virtual-functions.html