इंटरफ़ेस से अवांछित फ़ंक्शंस को कैसे हटाएं

Question

मेरे पास एक इंटरफ़ेस क्लास MyFunction है।

virtual bool Eval(int& iReturnVal, size_t szArgumentCount, list<Param> lParameterList) = 0; 
virtual bool Eval(double& dReturnVal, size_t szArgumentCount, list<Param> lParameterList) = 0; 
virtual bool Eval(char*& zReturnVal, size_t szArgumentCount, list<Param> lParameterList) = 0; 

अब, MyFunction के किसी भी कार्यान्वयन केवल मूल्य किस प्रकार इसे वापस करने की जरूरत पर निर्भर करता है इन कार्यों में से एक को लागू करने की आवश्यकता होगी: वहाँ निम्नलिखित हस्ताक्षरों के साथ इस वर्ग में तीन कार्य हैं। लेकिन मुझे अन्य 3 कार्यों को लागू करना होगा, भले ही अन्य दो कार्य इस तरह हों:

virtual bool Eval(double& dReturnVal, size_t szArgumentCount, list<Param> lParameterList){return false;} 

जो इतना अच्छा नहीं दिखता है। या, मैं इस तरह के तीनों कार्यों को इंटरफ़ेस में घोषित कर सकता हूं:

virtual bool Eval(int& iReturnVal, size_t szArgumentCount, list<Param> lParameterList){return false;} 
virtual bool Eval(double& dReturnVal, size_t szArgumentCount, list<Param> lParameterList){return false;} 
virtual bool Eval(char*& zReturnVal, size_t szArgumentCount, list<Param> lParameterList){return false;} 

जो बदसूरत दिखता है। इन दोनों की कम बदसूरत क्या है? या ऐसा करने का एक बेहतर तरीका है?

संपादित करें:

डी ईद्भूजर की विधि पर:

#include <iostream> 

using namespace std; 

class Base 
{ 
    public: 
     template<typename T> 
      void F(T){cout << "Type T" << endl;} 
}; 

class Imp : public Base 
{ 
    public: 
     template<int> 
      void F(int){cout << "Type int" << endl;} 
}; 

int main(int argc, char** argv) 
{ 
    Base* pB; 
    Imp oI; 
    pB = &oI; 

    pB->F(1); 
} 

विशेषज्ञता तरह लग रहा है वर्गों में लागू नहीं होता है, हालांकि व्युत्पन्न। चूंकि टेम्पलेट फ़ंक्शन आभासी नहीं हो सकते हैं, यह एक निराशाजनक स्थिति है जो ऐसा लगता है।

Answer 1

यह एक संकेत है कि आपके इंटरफ़ेस-डिज़ाइन को फिर से क्रियान्वित करने की आवश्यकता हो सकती है, जब इंटरफ़ेस को लागू करने वाले वर्गों में पूरी तरह से विधियों की आवश्यकता नहीं होती है। शायद आप इस इंटरफेस को 3 इंटरफेस में विभाजित कर सकते हैं।

एक और संभावना उस से एक रैपर-इंटरफ़ेस बनाना होगा, जो अनियंत्रित 2 विधियों के लिए डिफ़ॉल्ट मान देता है। लेकिन इस मामले में आप 3 इंटरफेस के साथ-साथ (मूल मूल-इंटरफेस -> 4 इंटरफेस कुल) के साथ समाप्त हो जाएंगे। यदि आपके पास मूल इंटरफ़ेस बदलने की कोई संभावना नहीं है तो यह समाधान स्वीकार्य होगा।

Answer 2

के बाद से वहाँ() Eval में इस्तेमाल किया प्रकार और कार्यान्वयन की संख्या के बीच एक-से-एक मानचित्रण, एक टेम्पलेट सदस्य समारोह काम करना चाहिए।

class MyFunction { 

    template <class T> 
    bool Eval(T& returnVal, size_t szArgumentCount, list<Param> lParameterList) 
     { return false; } 
}; 

फिर उन प्रकारों के लिए विशेषज्ञता लागू करें जो झूठी वापसी नहीं करनी चाहिए।

इस झूठे और तीन कार्यान्वयन कि किसी भी मामले में की जरूरत होगी वापस जाने के लिए केवल एक सामान्य कार्यान्वयन की आवश्यकता है।

Answer 3

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

double dd; 
int ii; 
char* ss; 
variant vv; 
ptr->Eval(&vv, ...); 
switch (vv.type) { 
    case DOUBLE: dd = vv.dd; break; 
    case INTEGER: ii = vv.ii; break; 
    case STRING: ss = vv.ss; break; 
} 

जाहिर है मैं त्रुटि जाँच और की तरह छोड़ दिया गया है, लेकिन यह बहुत है कि मैं क्या लगता है कि तुम क्या करने की योजना बना रहे हैं के समान है:

double dd; 
int ii; 
char* ss; 
switch (ptr->type) { 
    case DOUBLE: ptr->Eval(&dd, ...); break; 
    case INTEGER: ptr->Eval(&ii, ...); break; 
    case STRING: ptr->Eval(&ss, ...); break; 
} 

की तरह कुछ हो जाता है।