È valido avere due cast impliciti nella costruzione di un oggetto in C++?

Question

Considerate le seguenti due firme del costruttore, dovrebbe essere possibile costruire un Couple con Couple("George", "Nora")? Il mio compilatore si lamenta dell'errore mostrato di seguito. Se lo chiamo con Couple(std::string("George"), std::string("Nora")), compila OK. Immagino che ci sia un problema con il casting implicito che mi sorprende dato che sebbene char * to string andrebbe bene.

class Person 
{ 
    public: 
     Person(const std::string& name); 
}; 

class Couple 
{ 
    public: 
     Coordinate(const Person& p1, const Person& p2, const Optional<Person>& = Optional<Person>()); 
}; 

TestCouple.cpp:69: error: no matching function for call to `Couple::Couple(const char[7], const char[5])' 
TestCouple.h:24: note: candidates are: Couple::Couple(const Person&, const Person&, const Optional<fox::Person>&) 

Answer 1

In effetti, una sequenza di conversione non può contenere più di un'user-implicita conversione definita; lo standard lo specifica in C++ 11 12.3/4:

Al massimo una conversione definita dall'utente (funzione di costruzione o conversione) viene implicitamente applicata a un singolo valore.

Nel tuo caso, due sarebbe necessario (char const[] a std::string-Person), e la conversione in modo implicito non è possibile.

Answer 2

Si è verificato un problema con la conversione implicita. Comporterà solo una conversione implicita per un valore, quindi è possibile eseguire sia Couple(std::string("a"), std::string("b")) o Couple(Person("a"), Person("b")), ad esempio, ma Couple("a", "b") richiederebbe al compilatore di inserire due conversioni implicite per valore. Questo non è consentito dallo standard, perché causerebbe codice che potrebbe essere difficile da capire correttamente ed essere computazionalmente costoso da compilare.

Answer 3

Conversione implicita concatenata non consentita. Se A convertire implicitamente in B e B può implicitamente convertire in C, allora non significa che A convertire implicitamente in C.

//given three objects as 
A a; 
B b' 
C c; 

//premises 
b = a; //a can convert into b (implicitly) 
c = b; //b can convert into c (implicitly) 

//then it does not follow this 
c = a; //a CANNOT convert into c (implicitly) 

//you need to write this at least 
c = static_cast<B>(a); //ok