इस टेम्पलेट को ओवरलोड किए गए गैर-टेम्पलेट फ़ंक्शन पर चुनने वाला संकलक क्यों है?

Question

कुलपति ++ 2010 का उपयोग करना, निम्नलिखित दिया:

class Base { }; 
class Derived : public Base { }; 

template<class T> void foo(T& t); // A 
void foo(Base& base);    // B 

Derived d; 
foo(d);       // calls A 
foo(static_cast<Base&>(d));  // calls B 

मैं 'बी' चाहते हैं इसके बाद के संस्करण कहा जाता है। मैं इसे Base पर एक कलाकार के साथ प्राप्त कर सकता हूं, लेकिन यह आवश्यक क्यों है?

मैं चाहता हूँ टेम्पलेट समारोह सभी प्रकार Base से प्राप्त नहीं करने के लिए कहा जा करने के लिए (में निर्मित प्रकार, आदि), लेकिन मैं चाहता हूँ गैर टेम्पलेट अधिभार Base से प्राप्त प्रकार के लिए कहा जाता था, ग्राहक की आवश्यकता के बिना स्पष्ट रूप से कास्ट करने के लिए। मैंने ओवरलोड को टेम्पलेट की विशेषज्ञता बनाने की भी कोशिश की, लेकिन उसी मामले में वही व्यवहार होता है। जो मैं ढूंढ रहा हूं उसे प्राप्त करने का बेवकूफ तरीका क्या है?

Answer 1

सभी चीजें बराबर होती हैं, फ़ंक्शन टेम्पलेट्स पर नॉनटेम्प्लेट फ़ंक्शंस को प्राथमिकता दी जाती है। हालांकि, आपके परिदृश्य में, सभी चीजें बराबर नहीं हैं: (ए) T = Derived के साथ एक सटीक मिलान है, लेकिन (बी) तर्क के व्युत्पन्न-से-बेस रूपांतरण की आवश्यकता है।

#include <type_traits> 
#include <utility> 

template <typename T> 
typename std::enable_if< 
    !std::is_base_of<Base, T>::value 
>::type foo(T& x) 
{ 
} 

void foo(Base& x) 
{ 
} 

:

आप SFINAE का उपयोग करके विशिष्ट मामलों (यह एक तरह) के लिए इस के आसपास काम कर सकते हैं एक प्रकार Base से ली गई है उस के साथ instantiated जा रहा से (ए) को रोकने के लिए (प्रतिस्थापन विफलता कोई त्रुटि नहीं है)

Answer 2

टेम्पलेट संस्करण का चयन किया जा रहा है क्योंकि अधिभारित संस्करण की तुलना में Derived के तर्क के साथ बुलाया जाने वाला यह एक बेहतर मिलान है। आप टेम्पलेट संस्करण को ओवरलोड रिज़ॉल्यूशन से ड्रॉप करने के लिए SFINAE का उपयोग कर सकते हैं ताकि Base या Derived के तर्कों के साथ कॉल करते समय अन्य संस्करण का चयन किया जा सके।

#include <type_traits> 
#include <iostream> 

class Base { }; 
class Derived : public Base { }; 

template<class T> 
typename std::enable_if< 
    std::is_base_of<Base, T>::value == false 
>::type 
foo(T&) 
{ 
    std::cout << "template foo" << std::endl; 
} 


void foo(Base&) 
{ 
    std::cout << "non-template foo" << std::endl; 
} 


int main() 
{ 
    Derived d; 
    Base b; 

    foo(d); 
    foo(b); 
}