एडीएल के दौरान फ़ंक्शन टेम्पलेट को कम से कम प्राथमिकता कैसे बनाएं?

Question

मुझे एक समस्या है जहां मैं एक फ़ंक्शन foo का एक सामान्य संस्करण प्रदान करना चाहता हूं जो केवल तब लागू हो सकता है जब किसी आमंत्रण के लिए बिल्कुल कोई अन्य मिलान न हो। मैं निम्नलिखित कोड को कैसे संशोधित कर सकता हूं जैसे last_resort::fooderived::typebase::foo से अधिक खराब मिलान है? मैं एक समाधान खोजना चाहता हूं जिसमें bar की परिभाषा को संशोधित करने में शामिल नहीं है और जो last_resort::foo के तर्क के प्रकार को संरक्षित रखेगा।

#include <iostream> 

namespace last_resort 
{ 

template<typename T> void foo(T) 
{ 
    std::cout << "last_resort::foo" << std::endl; 
} 

} 

template<typename T> void bar(T) 
{ 
    using last_resort::foo; 
    foo(T()); 
} 

namespace unrelated 
{ 

struct type {}; 

} 

namespace base 
{ 

struct type {}; 

void foo(type) 
{ 
    std::cout << "base::foo" << std::endl; 
} 

} 

namespace derived 
{ 

struct type : base::type {}; 

} 

int main() 
{ 
    bar(unrelated::type()); // calls last_resort::foo 
    bar(base::type());  // calls base::foo 
    bar(derived::type()); // should call base::foo, but calls last_resort::foo instead 

    return 0; 
} 

Answer 1

last_resort::foo अधिभार disable_if के साथ सेट से हटाया जा सकता। विचार last_resort::foo(T) को अक्षम करना है यदि foo(T) अन्यथा अच्छी तरह से गठित किया गया है।

namespace test 
{ 

template<typename T> struct has_foo { ... }; 

} 

namespace last_resort 
{ 

template<typename T> 
    struct disable_if_has_foo 
    : std::enable_if< 
     !test::has_foo<T>::value 
     > 
{}; 

template<typename T> 
    typename disable_if_has_foo<T>::type foo(T) 
{ 
    std::cout << "last_resort::foo" << std::endl; 
} 

} 

उत्पादन:

$ g++ last_resort.cpp 
$ ./a.out 
last_resort::foo 
base::foo 
base::foo 

This answer बताता है कि कैसे एक समारोह (foo) void लौटने के अस्तित्व के लिए जाँच के लिए एक समाधान का निर्माण करने यह last_resort::foo(T)foo के लिए सबसे खराब मैच होने के लिए कारण बनता है।

Answer 2

आप इसके बारे में ज्यादा कुछ नहीं कर सकते हैं। दोनों foo फ़ंक्शन ओवरलोड सेट में हैं। लेकिन आपका last_resort एक बेहतर मिलान है क्योंकि इसे व्युत्पन्न :: प्रकार() के लिए आधार :: foo के विपरीत रूपांतरण की आवश्यकता नहीं है। केवल उस मामले में जहां दो उम्मीदवार पैरामीटर और संभावित रूपांतरणों के आधार पर "समान रूप से अच्छे" हैं, एक गैर-टेम्पलेट को प्राथमिकता दी जाती है।

Answer 3

derived::type की घोषणा के बाद आप derived::type टाइप करने के लिए bar का अधिभार प्रदान कर सकते हैं। यह namespace derived में हो सकता है या नहीं।

void bar(derived::type) 
{ 
    foo(derived::type()); 
} 

Answer 4

इस बारे में के रूप में बुरा के रूप में यह हो जाता है होगा:

struct badParam { template <typename T> badParam(T t) { } }; 
namespace last_resort { 
    void foo(badParam, int dummy = 0, ...) { 
    std::cout << "last_resort::foo" << std::endl; 
    } 
} 

आप एक उपयोगकर्ता-निर्धारित रूपांतरण, एक डिफॉल्ट पैरामीटर और एक अप्रयुक्त अंडाकार मिल गया है।

[संपादित करें]

थोड़ा सा संस्करण है, T को बचाने के लिए मैं डमी पैरामीटर के लिए उपयोगकर्ता परिभाषित रूपांतरण ले जाया गया:

struct badParam { 
    badParam() { } 
    operator int() { return 42; } 
}; 
namespace last_resort { 
    template <typename T> void foo(T t, int dummy = badParam(), ...) { 
    std::cout << "last_resort::foo" << std::endl; 
    } 
}