Implicitamente chiamando costruttore di copia

Question

Considerate:

struct Foo 
{ 
    Foo(std::string str) {} 
}; 

struct Bar 
{ 
    Bar(Foo f) {} 
}; 

int main(int argc, char* argv[]) 
{ 
    Foo f("test"); 

    Bar b1(f); 
    Bar b2(std::string("test")); 
    Bar b3("test"); 

    return 0; 
} 

Questo non riesce a compilare sulla dichiarazione di b3 ('non in grado di convertire l'argomento 1 da 'const char [5]' a 'Foo''). Il che ha senso, perché non esiste un modo diretto per convertire il const-char in un Foo. Tuttavia, c'è un modo per convertire il const char in una std :: string, e quindi usarlo per costruire un Foo (che è ciò che sta accadendo in b1 e b2), ed è quello che voglio perché rende l'API più carina da usare (non dover istanziare un Foo o uno std :: string esplicitamente ogni volta).

Quindi la mia domanda è: esiste un modo per consentire al compilatore di chiamare implicitamente il costruttore di copie Foo (std :: string)? In altre parole, c'è un modo per fare una dichiarazione come quella di b3, lasciare che sia uguale a b2 e senza dichiarare un costruttore di copia const char * per Foo? (che l'ultima cosa è la via ovvia ma il mio codice reale non è ovviamente così semplice, e preferirei non dover aggiungere costruttori di copia const char * e gestire tutte le altre inizializzazioni nei costruttori correttamente e tenerlo in sincronizzazione con il costruttore std :: string copy).

Answer 1

quello di cambiare questo:

struct Bar 
{ 
    Bar(Foo f) {} 
}; 

a

struct Bar 
{ 
    Bar(Foo f) {} 
    Bar(std::string f) {} 
}; 

utilizzando il polimorfismo ...

Answer 2

Se C++ 11 è accettabile, si potrebbe aggiungere un costruttore delegando ad Foo che prende un const char* e chiama semplicemente l'altro costruttore:

struct Foo 
{ 
    Foo(std::string str) {} 
    Foo(const char* str) : Foo(std::string(str)) {} 
}; 

In alternativa, è possibile utilizzare C++ 14 di std::string letterale:

using namespace::std::string_literals; 
Bar b3("test"s); 

Si potrebbe anche emulare un costruttore di delegare avendo entrambi i costruttori chiamano una funzione separata:

struct Foo 
{ 
    Foo(std::string str) { init(str); } 
    Foo(const char* str) { init(str); } 
    void init(std::string str) {} 
}; 

L'aspetto negativo della sopra è necessario riflettere attentamente su tutto ciò che si stava facendo negli elenchi di inizializzazione che ora è necessario fare nel corpo di init.