टेम्पलेट पैरामीटर

Question

पर आधारित उचित प्रति-कन्स्ट्रक्टर का चयन करना मैं टेम्पलेट तर्क मान के आधार पर किसी सदस्य फ़ंक्शन (कॉपी कन्स्ट्रक्टर) के कार्यान्वयन का चयन करना चाहता हूं। मुझे लगता है कि दो दृष्टिकोण हैं: SFINAE और टेम्पलेट आंशिक विशेषज्ञता।

पिछले एक माना जाता है कि इस तरह दिखता है:

#include <iostream> 

template<typename A, bool sw> 
struct B 
{ 
    B() {} 
    B(const B &b); 
}; 

template<typename A> 
B<A, false>::B(const B<A, false> &b) 
{ 
    std::cout << "false\n"; 
} 

template<typename A> 
B<A, true>::B(const B<A, true> &b) 
{ 
    std::cout << "true\n"; 
} 

int main() 
{ 
} 

यह संकलन नहीं करता है: nested name specifier 'B<A, false>::' for declaration does not refer into a class, class template or class template partial specialization।

SFINAE दृष्टिकोण भी विफल रहता है:

#include <type_traits> 
#include <iostream> 

template<typename A, bool sw> 
struct B 
{ 
    B() {} 

    template<typename U = typename std::enable_if<sw, B>::type> 
    B(const U &b) 
    { 
     std::cout << "true\n"; 
    } 

    template<typename U = typename std::enable_if<!sw, B>::type> 
    B(const U &b) 
    { 
     std::cout << "false\n"; 
    } 
}; 

int main() 
{ 
    { 
     B<int, true> b; 
     auto bc = b; // cout << true 
    } 
    { 
     B<int, false> b; 
     auto bc = b; // cout << false 
    } 
} 

संकलन त्रुटि यहाँ constructor cannot be redeclared और no type named 'type' in 'std::enable_if<false, B<int, false> >'; 'enable_if' cannot be used to disable this declaration है।

क्या समस्याएं ठीक करने या अन्यथा टेम्पलेट पैरामीटर के आधार पर उपयुक्त प्रति-निर्माता का चयन करने का कोई तरीका है?

Answer 1

template <typename A, bool sw> 
struct B 
{ 
    B() = default; 

    B(const B& b) : B(b, std::integral_constant<bool, sw>{}) {} 

private: 
    B(const B& b, std::true_type) 
    { 
     std::cout << "true\n"; 
    } 

    B(const B& b, std::false_type) 
    { 
     std::cout << "false\n"; 
    } 
}; 

DEMO

Answer 2

मैं जानता हूँ कि यह एक न्यूनतम उदाहरण है, लेकिन क्या

B(const B& b) { 
    if(sw) { 
    std::cout << "true\n"; 
    } else { 
    std::cout << "false\n"; 
    } 
} 

Answer 3

@Joachim Pileborg के रूप में टिप्पणी में कहा साथ कुछ गड़बड़ है, तो आप एक वर्ग का सिर्फ एक सदस्य विशेषज्ञ नहीं कर सकते , आपको पूरी कक्षा का विशेषज्ञ होना है। तो अपने आंशिक विशेषज्ञता इस तरह दिखेगा:

template<typename A, bool sw> 
struct B 
{ 
    B() {} 
    B(const B &b); 
}; 

//Specialize when sw is false 
template<typename A> 
struct B<A, false> 
{ 
    //The constructor in the specialized struct print false 
    B(const B &b) 
    { 
     std::cout << "false\n"; 
    } 
}; 

//Specialize when sw is true 
template<typename A> 
struct B<A, true> 
{ 
    //The constructor in the specialized struct print true 
    B(const B &b) 
    { 
     std::cout << "true\n"; 
    } 
}; 

सबसे अच्छा समाधान आप SFINAE के लिए प्राप्त कर सकते हैं @Piotr Skotnicki द्वारा दिया गया था