Warum kann nur implizit Compiler char * std :: string in einigen Fällen

Question

Diese Arbeit umwandeln:

struct WithString { 
    WithString(std::string){}; 
}; 

void takeString(std::string){} 

//implicit conversions: 
takeString("hello"); 
WithString("hello"); 

Aber dies nicht:

WithString makeWithString() { return "hello";} 

// error: no viable conversion from returned value of type 'const char [6]'... 

Wenn "Hallo" wird implizit umgewandelt std::string in den ersten beiden Fällen, warum kann es nicht im letzten Fall sein? Beachten Sie, dass ich den -Konstruktor nicht als explicit angegeben habe, also würde ich eine solche Konvertierung erwarten.

Ich kann das Verhalten erhalten, indem dies zu tun arbeiten:

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

bin ich über diese Kuriosität nur neugierig. Wenn ich eine Schätzung postuliere, würde ich sagen, dass es in den ersten beiden Arbeitsfällen die Umwandlung zwischen const char * bis std::string ist, aber im Fehlerfall würde dies stattdessen eine Kette von 2 Umwandlungen erfordern, zuerst von const char * bis std::string, und dann von std::string zu WithString. Vielleicht ist das der Grund, aber ich bin mir nicht sicher.

Answer 1

Ihre Methode:

WithString makeWithString() { return "hello";} 

benötigt zwei Conversions: Die implizite const-char - * - to-std :: string Umwandlung, dann eine Konstruktion eines WithString Objekt. C++ erlaubt höchstens eine davon implizit. Siehe auch die Diskussion hier:

Non-const copy constructor and implicit conversions on return value

Answer 2

I would say it is because in the first two working cases, the conversion is between const char * to std::string, but in the error case, this would instead require a chain of 2 conversion, first from const char * to std::string, and then from std::string to WithString. So perhaps that is the reason, but I'm not sure.

Genau.

Ohne Ihre const char* Konstruktor Überlastung dies:

WithString makeWithString() { return "hello";} 

würde zwei benutzerdefinierte implizite Konvertierungen erfordern; eins zu std::string und ein anderes zu WithString. Das ist nicht möglich.

Hier gibt es aber nur eine implizite Konvertierung (zu std::string):

takeString("hello"); 

Und das gleiche ist hier richtig, denn die nachfolgende "Umwandlung" zu WithString explizit:

WithString("hello"); 

I can get the behavior to work by doing this:

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

Ja, das sollten Sie tun.

Answer 3

liest implicit conversions Abschnitt in dem C++ Standard. Ich habe den folgenden Code in VS 2015 versucht und es kompiliert ohne Fehler.

#include <string> 

struct WithString { 
    WithString(std::string) {}; 
}; 

void takeString(std::string) {} 

//implicit conversions: 
void someFunc() 
{ 
    takeString("hello"); 
    WithString("hello"); 
    WithString t = "hello"; 
} 

WithString makeWithString() { return "hello"; } 

Es scheint, dass VS2015 falsch ist (eine Umwandlung von const char * string als Standardkonvertierung Behandlung).Der folgende Code sollte nach dem Standard arbeiten, aber erzeugt einen Fehler in VS2015:

WithString makeWithString() { return "hello"s; } 
WithString t = "hello"s; 

Siehe auch copy initialization. In den Notes ruft es explizit WithString t = "hello"; einen Fehler auf.