sovraccarichi booleani e stringhe dell'operatore di assegnazione (C++)

Question

Sto definendo più sovraccarichi dell'operatore assegnazione come segue:

foo.h

class Foo 
{ 
private: 
    bool my_bool; 
    int my_int; 
    std::string my_string; 
public: 
    Foo& operator= (bool value); 
    Foo& operator= (int value); 
    Foo& operator= (const std::string& value); 
}; 

Foo.cpp

// Assignment Operators. 
Foo& Foo::operator= (bool value) {my_bool = value; return *this;} 
Foo& Foo::operator= (int value) {my_int = value; return *this;} 
Foo& Foo::operator= (const std::string& value) {my_string = value; return *this;} 

Ed ecco il mio main.cpp (vedere il commento contrassegnato SURPRISE):

Foo boolFoo; 
Foo intFoo; 
Foo stringFoo; 

// Reassign values via appropriate assignment operator. 
boolFoo = true;    // works...assigned as bool 
intFoo = 42;     // works...assigned as int 
stringFoo = "i_am_a_string"; // SURPRISE...assigned as bool, not string 

std::string s = "i_am_a_string"; 
stringFoo = s;     // works...assigned as string 

// works...but awkward 
stringFoo = static_cast<std::string>("i_am_a_string"); 

Domanda: Qualcuno può dirmi perché un valore letterale stringa non trasmesso viene valutato in un contesto booleano?

Answer 1

Il C++ standard definisce regole di risoluzione di sovraccarico nel capitolo 13.3, ci si trova:

13.3.3.2 Classifica sequenze conversione implicita [over.ics.rank]

Quando si confrontano le forme di base delle sequenze di conversione implicite (come definito in 13.3.3.1)

- una sequenza di conversione standard (13.3.3.1.1) è una sequenza di conversione migliore di una definita dall'utente sequenza di conversione o sequenza di conversione ellissi e

- una sequenza di conversione definita dall'utente (13.3.3.1.2) è una sequenza di conversione migliore rispetto a una sequenza di conversione ellissi (13.3.3.1.3).

Ciò significa che il compilatore preferisce una sequenza standard di conversione dalla stringa letterale bool o int se disponibile. Ora, quali conversioni standard sono rilevanti? Nel suo caso, questi due sono rilevanti:

4,2 Array a puntatore conversione [conv.array]

Un Ivalue o rvalue di tipo “vettore di NT” o “matrici del limite sconosciuto di T "può essere convertito in un valore di tipo" puntatore a T ". Il risultato è un puntatore al primo elemento dell'array.

Questa conversione trasforma la stringa letterale, che è di tipo const char[N], in un const char*. La seconda è:

4.12 conversioni booleane [conv.bool]

Un prvalue dell'aritmetica, censimento unscoped, puntatore o puntatore al Tipo di utente può essere convertito in un prvalue di digitare bool. Un valore zero, un valore puntatore nullo o un valore puntatore membro nullo viene convertito in false; qualsiasi altro valore viene convertito in true. Un valore di tipo std::nullptr_t può essere convertito in un valore di tipo bool; il valore risultante è false.

Questo è il motivo per cui il puntatore viene convertito in bool. Poiché esiste una sequenza di conversione standard, la conversione definita dall'utente in std::string non viene utilizzata.

Per risolvere il problema, suggerisco di aggiungere un'altra versione sovraccaricata che richiede const char* e inoltra la chiamata al sovraccarico const std::string&.

Answer 2

Daniel è giusto.

La risposta breve è che std::string non è un tipo built-in e, come tale, non ottiene alcun trattamento preferenziale magico. E, sfortunatamente, il tipo di stringa letterale come "hi world" è nonstd::string, ma un tipo di puntatore che si converte più facilmente nel tipo predefinito bool che nel "definito dall'utente" ^{& dagger;} tipo std::string.

In sostanza, la risposta è: Benvenuto C++.

^{& pugnale; Sì, lo so, è dalla libreria standard di e, no, non importa.}