web-dev-qa-db-fra.com

Copier un tableau de caractères non signé non terminé avec un caractère null dans std :: string

Si le tableau était null-terminé, ce serait assez simple:

unsigned char u_array[4] = { 'a', 's', 'd', '\0' };
std::string str = reinterpret_cast<char*>(u_array);
std::cout << "-> " << str << std::endl;

Cependant, je me demande quel est le moyen le plus approprié de copier un tableau de caractères unsigned unsigned, comme suit:

unsigned char u_array[4] = { 'a', 's', 'd', 'f' };

dans un std::string. 

Est-il possible de le faire sans parcourir le tableau de caractères unsigned char?

Merci à tous.

c++stringcopynull-terminatedarrays
36
karlphillip

std::string a un constructeur qui prend une paire d'itérateurs et unsigned char peut être converti (d'une manière définie par l'implémentation) en char pour que cela fonctionne. Il n'y a pas besoin d'un reinterpret_cast.

unsigned char u_array[4] = { 'a', 's', 'd', 'f' };

#include <string>
#include <iostream>
#include <ostream>

int main()
{
    std::string str( u_array, u_array + sizeof u_array / sizeof u_array[0] );
    std::cout << str << std::endl;
    return 0;
}

Bien entendu, une fonction de modèle "tableau" est plus robuste que le calcul sizeof.

43
CB Bailey

Bien, apparemment, std :: string a un constructeurqui pourrait être utilisé dans ce cas:

std::string str(reinterpret_cast<char*>(u_array), 4);
15
karlphillip

Lors de la construction d'une chaîne sans spécifier sa taille, le constructeur effectue une itération sur un tableau de caractères et recherche le caractère null-terminator, à savoir '\0' caractère. Si vous n'avez pas ce caractère, vous devez spécifier explicitement la longueur, par exemple:

// --*-- C++ --*--

#include <string>
#include <iostream>


int
main ()
{
    unsigned char u_array[4] = { 'a', 's', 'd', 'f' };
    std::string str (reinterpret_cast<const char *> (u_array),
                     sizeof (u_array) / sizeof (u_array[0]));
    std::cout << "-> " << str << std::endl;
}
4
user405725

std :: string a une méthode nommée assign. Vous pouvez utiliser un caractère * et une taille.

http://www.cplusplus.com/reference/string/string/assign/

3
foobar1234

Vous pouvez utiliser ce constructeur std::string:

string ( const char * s, size_t n );

alors dans votre exemple:

std::string str(u_array, 4);
2
Benoit Thiery

Cela devrait le faire:

std::string s(u_array, u_array+sizeof(u_array)/sizeof(u_array[0]));
2
cpx

Ew, pourquoi le casting?

 std::string str(u_array, u_array + sizeof(u_array));

Terminé.

0
Lightness Races in Orbit

Vous pouvez créer un pointeur de caractère pointant vers le premier caractère et un autre pointant vers le dernier-dernier-dernier et construire en utilisant ces deux pointeurs comme itérateurs. Ainsi:

std::string str(&u_array[0], &u_array[0] + 4);
0
Raedwald

Essayer:

std::string str;
str.resize(4);
std::copy(u_array, u_array+4, str.begin());
0
tibur

Il y a toujours un problème lorsque la chaîne elle-même contient un caractère null et que vous essayez ensuite d'imprimer la chaîne:

char c_array[4] = { 'a', 's', 'd', 0 };

std::string toto(array,4);
cout << toto << endl;  //outputs a 3 chars and a NULL char

Toutefois....

cout << toto.c_str() << endl; //will only print 3 chars.

Son temps comme celui-ci quand vous voulez juste abandonner la gentillesse et utiliser C nu.

0
plgDavid

std :: string a un constructeur prenant un tableau de char et une longueur.

unsigned char u_array[4] = { 'a', 's', 'd', 'f' };
std::string str(reinterpret_cast<char*>(u_array), sizeo(u_array));
0
johannes

Bien que la question était de savoir comment "copier un tableau unsigned char non terminé par un null [...] dans un std::string", je remarque que, dans l'exemple donné, cette chaîne n'est utilisée que comme entrée pour std::cout.

Dans ce cas, bien sûr, vous pouvez éviter la chaîne et simplement faire

std::cout.write(u_array, sizeof u_array);
std::cout << std::endl;

je pense que cela pourrait résoudre le problème que le PO était essayer à résoudre.

0
Ben Hekster