selezionando il costruttore di copia appropriato in base ai parametri del modello

Question

Desidero selezionare l'implementazione di una funzione membro (costruttore di copie) basata su un valore di argomento del modello. Suppongo che ci siano due approcci: SFINAE e specializzazione parziale del modello.

L'ultimo presunto assomiglia a questo:

#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() 
{ 
} 

Esso non può essere compilato: nested name specifier 'B<A, false>::' for declaration does not refer into a class, class template or class template partial specialization.

approccio SFINAE non troppo:

#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 
    } 
} 

l'errore di compilazione qui è constructor cannot be redeclared e no type named 'type' in 'std::enable_if<false, B<int, false> >'; 'enable_if' cannot be used to disable this declaration.

C'è un modo per risolvere i problemi o altrimenti selezionare il costruttore di copia appropriato in base ai parametri del modello?

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

So che questo è un esempio minimo, ma che c'è di male

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

Answer 3

Come ha detto @Joachim Pileborg in commento, non si può specializzare solo un membro di una classe , devi specializzare l'intera classe. Così il vostro specializzazione parziale sarà simile a questa:

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"; 
    } 
}; 

La soluzione migliore si può ottenere per SFINAE è stato dato da @Piotr Skotnicki