Come aggiungere un char a una std :: string?

Question

Il seguente fallisce con l'errore prog.cpp:5:13: error: invalid conversion from ‘char’ to ‘const char*’

int main() 
{ 
    char d = 'd'; 
    std::string y("Hello worl"); 
    y.append(d); // Line 5 - this fails 
    std::cout << y; 
    return 0; 
} 

Ho anche provato, quanto segue, che compila, ma si comporta in modo casuale in fase di esecuzione:

int main() 
{ 
    char d[1] = { 'd' }; 
    std::string y("Hello worl"); 
    y.append(d); 
    std::cout << y; 
    return 0; 
} 

Siamo spiacenti per questa domanda stupida, ma ho cercato in giro google, quello che ho potuto vedere sono solo "array di caratteri a char ptr", "PTR char a char allineamento", ecc

Answer 1

y += d; 

userei += operatore al posto di funzioni con nome.

Answer 2

Uso push_back():

std::string y("Hello worl"); 
y.push_back('d') 
std::cout << y; 

Answer 3

Prova l'operatore + = link text, metodo link text, o push_back() metodo link text

I link in questo post contengono anche esempi di come utilizzare le rispettive API append().

Answer 4

In aggiunta agli altri citati, uno dei costruttori di stringhe prende un carattere e il numero di ripetizioni per quel carattere. Quindi puoi usarlo per aggiungere un singolo carattere.

std::string s = "hell"; 
s += std::string(1, 'o'); 

Answer 5

Se si utilizza il push_back non c'è nessuna chiamata per il costruttore stringa. Altrimenti creerà un oggetto stringa tramite casting, quindi aggiungerà il carattere in questa stringa all'altra stringa. Troppo disturbo per un carattere molto piccolo;)

Answer 6

Per aggiungere un char a un var std :: string utilizzando il metodo append, è necessario utilizzare questo sovraccarico:

std::string::append(size_type _Count, char _Ch) 

Edit: vi trovate giusto ho frainteso il parametro size_type, visualizzato nella guida contestuale. Questo è il numero di caratteri da aggiungere. Quindi la chiamata corretta è

s.append(1, d); 

non

s.append(sizeof(char), d); 

O il modo più semplice:

s += d; 

Answer 7

il problema con:

std::string y("Hello worl"); 
y.push_back('d') 
std::cout << y; 

è che si deve avere la 'd' come opp osed to using a name of a char, come char d = 'd'; O mi sbaglio?

Answer 8

str.append(10u,'d'); //appends character d 10 times 

Avviso ho scritto 10u e non 10 per il numero di volte che mi piacerebbe aggiungere il carattere; sostituire 10 con qualsiasi numero.

Answer 9

int main() 
{ 
    char d = 'd'; 
    std::string y("Hello worl"); 

    y += d; 
    y.push_back(d); 
    y.append(1, d); //appending the character 1 time 
    y.insert(y.end(), 1, d); //appending the character 1 time 
    y.resize(y.size()+1, d); //appending the character 1 time 
    y += std::string(1, d); //appending the character 1 time 
} 

Si noti che in tutti questi esempi si potrebbe avere utilizzato un carattere letterale direttamente: y += 'd';.

Il tuo secondo esempio quasi avrebbe funzionato, per motivi non correlati. char d[1] = { 'd'}; non ha funzionato, ma char d[2] = { 'd'}; (notare che la matrice è la dimensione due) sarebbe stata lavorata all'incirca come const char* d = "d"; e una stringa letterale può essere aggiunta: y.append(d);.

Answer 10

provare a utilizzare il D come puntatore y.append (* d)

Answer 11

ho testare le varie proposte da loro esecuzione in un ciclo di grandi dimensioni. Ho usato microsoft visual studio 2015 come compilatore e il mio processore è un i7, 8Hz, 2GHz.

long start = clock(); 
    int a = 0; 
    //100000000 
    std::string ret; 
    for (int i = 0; i < 60000000; i++) 
    { 
     ret.append(1, ' '); 
     //ret += ' '; 
     //ret.push_back(' '); 
     //ret.insert(ret.end(), 1, ' '); 
     //ret.resize(ret.size() + 1, ' '); 
    } 
    long stop = clock(); 
    long test = stop - start; 
    return 0; 

Secondo questo test, i risultati sono i seguenti:

 operation    time(ms)   note 
------------------------------------------------------------------------ 
append      66015 
+=       67328  1.02 time slower than 'append' 
resize      83867  1.27 time slower than 'append' 
push_back & insert   90000  more than 1.36 time slower than 'append' 

Conclusione

+= sembra più comprensibile, ma se si mente circa la velocità, l'uso aggiungono