संकलक निम्नलिखित उदाहरण में मेरे फ़ंक्शन-टेम्पलेट अधिभार का चयन क्यों नहीं कर रहा है?

Question

को देखते हुए निम्नलिखित समारोह टेम्पलेट्स:

#include <vector> 
#include <utility> 

struct Base { }; 
struct Derived : Base { }; 

// #1 
template <typename T1, typename T2> 
void f(const T1& a, const T2& b) 
{ 
}; 

// #2 
template <typename T1, typename T2> 
void f(const std::vector<std::pair<T1, T2> >& v, Base* p) 
{ 
}; 

क्यों है यह है कि निम्नलिखित कोड हमेशा अधिभार # 1 के बजाय # 2 अधिभार का आह्वान?

int main() 
{ 
    std::vector<std::pair<int, int> > v; 
    Derived derived; 

    f(100, 200); // clearly calls overload #1 
    f(v, &derived);   // always calls overload #1 

    return 0; 
} 

यह देखते हुए कि f का दूसरा पैरामीटर Base की एक व्युत्पन्न प्रकार है, मुझे उम्मीद थी कि संकलक अधिभार # 2 का चयन करेंगे के रूप में यह # 1 अधिभार में सामान्य प्रकार की तुलना में एक बेहतर मुकाबला नहीं है।

क्या ऐसी कोई तकनीक है जिसका उपयोग मैं इन कार्यों को फिर से लिखने के लिए कर सकता हूं ताकि उपयोगकर्ता main फ़ंक्शन (यानी, तर्क प्रकारों के संकलक-कटौती का लाभ उठाने) में प्रदर्शित कोड लिख सकें?

Answer 1

आप या तो यह कर सकते हैं:

f(v, static_cast<Base*>(&derived)); 

या SFINAE का उपयोग पहले दूर करने के लिए चयन उम्मीदवार के रूप में कार्य करें:

// Install boost library and add these headers: 
#include <boost/utility/enable_if.hpp> 
#include <boost/type_traits.hpp> 

// #1 - change it to look like this (note the keyword void changed positions) 
template <typename T1, typename T2> 
typename boost::disable_if< 
    typename boost::is_convertible<T2, Base*>, void>::type 
f(const T1& a, const T2& b) 
{ 
}; 

// #2 - this one can stay the same 
template <typename T1, typename T2> 
void f(const std::vector<std::pair<T1, T2> >& v, Base* p) 
{ 
}; 

Answer 2

यह देखते हुए कि च का दूसरा पैरामीटर बेस

यह करने के लिए परिवर्तनीय है की एक व्युत्पन्न प्रकार है, लेकिन * यह एक ली गई है। पहले टेम्पलेट फ़ंक्शन को कोई रूपांतरण की आवश्यकता नहीं होती है, और दूसरे को एक की आवश्यकता होती है, इसलिए यह पहले को चुनता है।

यह दूसरा चुनता है:

f(v, static_cast<Base*>(&derived)); 

एक तरफ ध्यान दें पर, main रिटर्न एक int।

Answer 3

Koenig Lookup के बारे में स्पष्ट विषयों के अलावा जो संकलक (विशेष रूप से पुराने लोग काफी समस्याग्रस्त हैं) द्वारा लागू किया गया है, template specialization के संबंध में कुछ नुकसान हैं।

विशेषज्ञता के लिए प्रकारों को बिल्कुल मिलान करने की आवश्यकता होती है (सुनिश्चित नहीं है कि std यह कैसे परिभाषित करता है, लेकिन मेरे अनुभव से [gcc, msvc] एक व्युत्पन्न वर्ग मिलान नहीं किया जाएगा)। आप बेस * करने के लिए एक बदसूरत डाली जोड़ते हैं, तो ऐसा लगता है जैसे आप का इरादा काम करना चाहिए, व्युत्पन्न के लिए वैकल्पिक रूप से एक और विशेषज्ञता जोड़ने ...