सी ++ कब्रिस्तान सबसे अच्छा समाधान कब होता है?

Question

This question कुछ घंटों पहले यहां पूछा गया था और मुझे एहसास हुआ कि मैंने वास्तव में कभी भी अपने कोड में कॉन्वेंट रिटर्न प्रकारों का उपयोग नहीं किया है। उन के लिए यह सुनिश्चित नहीं है कि कॉन्वर्सिस क्या है, यह रिटर्न प्रकार (आमतौर पर) वर्चुअल फ़ंक्शंस को अलग करने की इजाजत देता है, बशर्ते कि प्रकार एक ही विरासत पदानुक्रम का हिस्सा हों। उदाहरण के लिए:

struct A { 
    virtual ~A(); 
    virtual A * f(); 
    ... 
}; 

struct B : public A { 
    virtual B * f(); 
    ... 
}; 

दो एफ() कार्यों के विभिन्न रिटर्न प्रकारों को कॉन्वेंट कहा जाता है।

struct B : public A { 
    virtual A * f(); 
    ... 
}; 

तो, मेरे सवाल: किसी को भी एक वास्तविक दुनिया उदाहरण है जहाँ लौट covariant आभासी कार्यों के प्रकार के लिए आवश्यक हैं है सी ++ के पुराने संस्करण, एक ही हो तो बी की तरह लग रहे करने के लिए होता वापसी प्रकार की आवश्यकता , या बस आधार सूचक या संदर्भ लौटने के लिए एक बेहतर समाधान का उत्पादन?

Answer 1

कैननिकल उदाहरण .clone()/.copy() विधि है। तो आप हमेशा

obj = obj->copy(); 

चाहे ओबीजे का प्रकार क्या हो।

संपादित करें: यह क्लोन विधि ऑब्जेक्ट बेस क्लास में परिभाषित की जाएगी (जैसा कि यह वास्तव में जावा में है)। तो अगर क्लोन को संविधान नहीं किया गया था, तो आपको या तो रूट बेस क्लास के तरीकों तक सीमित करना होगा, या प्रतिलिपि होगी (जिसमें प्रतिलिपि के स्रोत ऑब्जेक्ट की कक्षा की तुलना में केवल बहुत कम विधियां होंगी)।

Answer 2

एक और उदाहरण एक ठोस कारखाना है जो अमूर्त के बजाय कंक्रीट कक्षाओं में पॉइंटर्स लौटाएगा (मैंने फैक्ट्री में आंतरिक उपयोग के लिए इसका उपयोग किया है जब कारखाने को यौगिक वस्तुओं का निर्माण करना था)।

Answer 3

मुझे लगता है कि कारखाने के तरीकों की घोषणा करते समय कॉन्वर्सेंस उपयोगी हो सकता है जो एक विशिष्ट वर्ग लौटाता है, न कि इसकी बेस क्लास। This article काफी अच्छी तरह से इस परिदृश्य बताते हैं, और निम्न कोड उदाहरण में शामिल हैं:

class product 
{ 
    ... 
}; 

class factory 
{ 
public: 
    virtual product *create() const = 0; 
    ... 
}; 

---

class concrete_product : public product 
{ 
    ... 
}; 

class concrete_factory : public factory 
{ 
public: 
    virtual concrete_product *create() const 
    { 
     return new concrete_product; 
    } 
    ... 
}; 

Answer 4

यह परिदृश्य जहां उपयोग एक ठोस कारखाने करना चाहते ठोस उत्पादों उत्पन्न करने के लिए उपयोगी हो जाता है। तुम हमेशा पर्याप्त रूप से सामान्य है सबसे विशेष इंटरफ़ेस चाहते हैं ...

कोड का उपयोग कर ठोस कारखाने सुरक्षित रूप से लगता है कि कर सकते हैं कि उत्पादों ठोस उत्पादों रहे हैं, तो यह सुरक्षित रूप से साथ ठोस उत्पाद वर्ग द्वारा प्रदान की एक्सटेंशन का उपयोग कर सकते हैं अमूर्त वर्ग के संबंध में। इसे वास्तव में सिंटेक्टिक चीनी के रूप में माना जा सकता है, लेकिन यह वैसे भी मीठा है।

Answer 5

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

जब आप गब्बिन्स के पदानुक्रमों से संबंधित होते हैं, तो यह उपयोगी होता है, जहां कुछ ग्राहक बेस क्लास इंटरफ़ेस का उपयोग करना चाहते हैं, लेकिन अन्य क्लाइंट व्युत्पन्न क्लास इंटरफ़ेस का उपयोग करेंगे।स्थिरांक-शुद्धता लोप के साथ:

class URI { /* stuff */ }; 

class HttpAddress : public URI { 
    bool hasQueryParam(string); 
    string &getQueryParam(string); 
}; 

class Resource { 
    virtual URI &getIdentifier(); 
}; 

class WebPage : public Resource { 
    virtual HttpAddress &getIdentifier(); 
}; 

ग्राहक जो जानते हैं कि वे एक वेबपृष्ठ है (ब्राउज़रों, शायद) पता है कि यह क्वेरी पैरामीटर को देखने के लिए सार्थक है। ग्राहक जो बेस बेस क्लास का उपयोग कर रहे हैं, ऐसी कोई चीज़ नहीं जानते हैं। वे हमेशा HttpAddress& को URI& परिवर्तनीय या अस्थायी रूप से बाध्य करेंगे।

यदि उन्हें संदेह है, लेकिन यह नहीं पता कि उनके संसाधन ऑब्जेक्ट में एक HttpAddress है, तो वे dynamic_cast कर सकते हैं। लेकिन कॉन्वर्सिस "सिर्फ जानने" से बेहतर है और उसी कारण से कास्ट कर रहा है कि स्थैतिक टाइपिंग बिल्कुल उपयोगी है।

विकल्प हैं - URI पर getQueryParam फ़ंक्शन को चिपकाएं लेकिन hasQueryParam सबकुछ के लिए झूठी वापसी करें (यूआरआई इंटरफ़ेस को अव्यवस्थित करें)। WebPage::getIdentifier को URL& लौटने के लिए परिभाषित किया गया है, वास्तव में HttpIdentifier& लौटा रहा है, और कॉलर्स एक व्यर्थ dynamic_cast (कॉलिंग कोड को बंद कर देते हैं, और वेबपृष्ठ का दस्तावेज़ीकरण करते हैं जहां आप कहते हैं कि "यूआरएल लौटाया गया है एचटीपीएड्रेस को गतिशील रूप से जा सकता है")। getHttpIdentifier फ़ंक्शन WebPage पर जोड़ें (WebPage इंटरफ़ेस को अव्यवस्थित करें)। या केवल इसका उपयोग करने के लिए कॉन्वर्सिस का उपयोग करें, जो इस तथ्य को व्यक्त करता है कि WebPage में FtpAddress या MailtoAddress नहीं है, इसमें HttpAddress है।

आखिरकार एक उचित तर्क है कि आपको गब्बिन्स के पदानुक्रम नहीं होना चाहिए, केवल गब्बिन्स से संबंधित पदानुक्रमों को छोड़ दें। लेकिन वे कक्षाएं शुद्ध आभासी तरीकों के साथ आसानी से इंटरफेस हो सकती हैं, इसलिए मुझे नहीं लगता कि यह कॉन्वर्सिस का उपयोग करने की वैधता को प्रभावित करता है।

Answer 6

मैं static_casts से छुटकारा पाने के लिए मौजूदा कोड के साथ काम करते समय अक्सर अपने आप को covariance का उपयोग कर पाते हैं। आम तौर पर स्थिति इस के समान है:

class IPart {}; 

class IThing { 
public: 
    virtual IPart* part() = 0; 
}; 

class AFooPart : public IPart { 
public: 
    void doThis(); 
}; 

class AFooThing : public IThing { 
    virtual AFooPart* part() {...} 
}; 

class ABarPart : public IPart { 
public: 
    void doThat(); 
}; 

class ABarThing : public IThing { 
    virtual ABarPart* part() {...} 
};  

यह

AFooThing* pFooThing = ...; 
pFooThing->Part()->doThis(); 

और

ABarThing pBarThing = ...; 
pBarThing->Part()->doThat(); 

बजाय

static_cast<AFooPart>(pFooThing->Part())->doThis(); 

और

की

करने के लिए मुझे अनुमति देता है 10

static_cast<ABarPart>(pBarThing->Part())->doThat(); 

अब ऐसे कोड में आने पर मूल डिजाइन के बारे में बहस हो सकती है और क्या कोई बेहतर है - लेकिन मेरे अनुभव में अक्सर प्राथमिकताओं, लागत/लाभ इत्यादि जैसी बाधाएं होती हैं जो व्यापक डिजाइन सौंदर्यीकरण में हस्तक्षेप करती हैं और इस तरह के केवल छोटे कदमों की अनुमति दें।