que - funciones de cadenas de caracteres en c++

Copia de una matriz de caracteres sin signo terminada en nulo a std:: string

Question

Si la matriz fue terminada en nulo esto sería bastante sencillo:

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

Sin embargo, me pregunto cuál es la forma más adecuada de copiar una matriz de caracteres no firmada sin terminación nula , como la siguiente:

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

en una std::string .

¿Hay alguna manera de hacerlo sin iterar sobre la matriz de caracteres sin signo ?

Gracias a todos.

Answer 1

Al construir una cadena sin especificar su tamaño, el constructor iterará sobre una matriz de caracteres y buscará el terminador nulo, que es el carácter ''/0'' . Si no tiene ese carácter, debe especificar la longitud explícitamente, por ejemplo:

// --*-- 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;
}

Answer 2

Aunque la pregunta era cómo "copiar una matriz de caracteres unsigned char sin nulo [...] en una std::string ", observo que en el ejemplo dado esa cadena solo se usa como entrada para std::cout .

En ese caso, por supuesto, puedes evitar la cadena por completo y solo hacer

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

que creo que puede resolver el problema que el OP intentaba resolver.

Answer 3

Bueno, aparentemente std :: string tiene un constructor que podría usarse en este caso:

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

Answer 4

Esto debería hacerlo:

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

Answer 5

Ew, ¿por qué el elenco?

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

Hecho.

Answer 6

Puede crear un puntero de carácter que apunte al primer carácter y otro que apunte a uno más allá del último, y construir usando esos dos punteros como iteradores. Así:

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

Answer 7

Puede usar este constructor std::string :

string ( const char * s, size_t n );

entonces en tu ejemplo:

std::string str(u_array, 4);

Answer 8

Todavía hay un problema cuando la cadena contiene un carácter nulo e intenta imprimir posteriormente la cadena:

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

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

Sin embargo....

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

Son tiempos como estos cuando solo quieres deshacerte de la ternura y usar C. desnudo.

Answer 9

Tratar:

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

Answer 10

std :: string tiene un constructor que toma una matriz de caracteres y una longitud.

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

Answer 11

std :: string tiene un método llamado assign. Puede usar un char * y un tamaño.

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

Answer 12

std::string tiene un constructor que toma un par de iteradores y el unsigned char se puede convertir (en una implementación definida) a char para que funcione. No hay necesidad de 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;
}

Por supuesto, una función de plantilla de "tamaño de matriz" es más sólida que el tamaño de cálculo.