Perché può usare const char * come chiave per std :: map <std :: string, int>

Question

ho definire una struttura di dati

std::map<std::string, int> a; 

ho trovato posso passare const char * come chiave, come this:

a["abc"] = 1; 

Quale funzione fornisce la conversione automatica dei tipi da const char * a std :: string?

Answer 1

std::string ha un constructor that allows the implicit conversion from const char*.

basic_string(const CharT* s, 
       const Allocator& alloc = Allocator()); 

significa che una conversione implicita come

std::string s = "Hello"; 

è consentito.

è l'equivalente di fare qualcosa di simile

struct Foo 
{ 
    Foo() {} 
    Foo(int) {} // implicit converting constructor. 
}; 

Foo f1 = 42; 
Foo f2; 
f2 = 33 + 9; 

Se si voleva impedire la costruzione di conversione implicita, si contrassegna il costruttore come explicit:

struct Foo 
{ 
    explicit Foo(int) {} 
}; 

Foo f = 33+9; // error 
Foo f(33+9); // OK 
f = Foo(33+9); // OK 

Answer 2

C'è un costruttore per std: : stringa che accetta const char * come parametro.

string::string(const char*); 

A meno che il costruttore viene dichiarato esplicitamente il compilatore applicherà uno uso di conversione definita, se necessario, di chiamare qualsiasi funzione.

Answer 3

Vedere string constructor. Il costruttore fornisce la conversione per la chiave nella tua mappa. E 'equivalente a

a[std::string("abc")] = 1; 

Answer 4

In C++ se si commette un costruttore di classe che accetta un solo parametro, allora (a meno che non gli si dice contrario con explicit), il tipo di quel parametro sarà implicitly convertable alla classe.

std::string ha un tale costruttore per char *

Sì, questo può causare un comportamento imprevisto in occasione. Questo è il motivo per cui in genere si dovrebbe mettere explicit su costruttori a parametri singoli, a meno che non si desideri veramente queste conversioni non presidiate.