Eliminar char * después de asignarlo a una variable de cadena

He ejecutado el siguiente código y funciona perfectamente. Ya que se trata de punteros, solo quiero estar seguro. Aunque estoy seguro de que asignar char * a string hace una copia e incluso si elimino char *, string var conservará el valor.

#include  #include  #include  #include  int main() { std::string testStr = "whats up ..."; int strlen = testStr.length(); char* newCharP = new char[strlen+1]; memset(newCharP,'\0',strlen+1); memcpy(newCharP,testStr.c_str(),strlen); std::cout << " :11111111 : " << newCharP << "\n"; std::string newStr = newCharP ; std::cout << " 2222222 : " << newStr << "\n"; delete[] newCharP; newCharP = NULL; std::cout << " 3333333 : " << newStr << "\n"; } 

Acabo de cambiar un código en el proyecto de mi empresa y las funciones * se pasan entre funciones en C ++. El puntero char * se ha copiado a la cadena, pero el char * se elimina al final de la función. No pude encontrar ninguna razón específica para esto. Así que solo estoy eliminando el char *, tan pronto como se copia en una cadena. ¿Esto haría algún problema …?

PD: Ya hice esta pregunta en Codereview, pero recibí una sugerencia para pasarla a SO. Así que lo he marcado para cerrar allí y publicar la pregunta aquí.

No hay problema, siempre que newChar apunte a una cadena terminada en nulo y no sea nula en sí misma.

std::string tiene un constructor que permite una construcción implícita a partir de un const char* . Hace una copia de la cadena de caracteres representada por la entrada const char * por lo que funciona bajo el supuesto de que char* es una cadena terminada en nulo, ya que no hay otra manera de saber cuántos caracteres se deben copiar en el propio almacenamiento de datos de la cadena. . Además, la norma no permite un puntero NULL .

No, porque std::string copia el contenido de tu char* , por lo que puedes eliminarlo cuando ya no lo necesites.

El código está bien, si miras los constructores de std::basic_string aquí podrás deducir que std::string tiene dos constructores interesantes aquí:

 (4) string(char const*, size_type count, Allocator const& alloc = Allocator() ); (5) string(char const* s, Allocator const& alloc = Allocator() ); 

Ambos realizan una copia, y el primero lee exactamente los caracteres del count , mientras que el segundo lee hasta que encuentra un carácter NUL.


Dicho esto, le recomiendo activamente que no utilice la asignación dinámica aquí. Si quieres jugar con un búfer temporal, considera usar std::vector lugar.

 #include  #include  #include  #include  int main() { std::string testStr = "whats up ..."; unsigned strlen = testStr.length(); std::vector buffer(strlen+1); memset(&buffer[0],'\0',strlen+1); memcpy(&buffer[0], testStr.c_str(), strlen); std::cout << " :11111111 : " << &buffer[0] << "\n"; std::string newStr(&buffer[0]); std::cout << " 2222222 : " << newStr << "\n"; buffer.clear(); std::cout << " 3333333 : " << newStr << "\n"; } 

Nota: tanto el vector como la string tienen constructores de rangos, para construirlos a partir de una serie de iteradores, que a propósito evité usar para evitar confusiones y que usted se sienta abrumado. Solo debes saber que podrías haberlos usado para evitar llamar a memcpy y arriesgar un desbordamiento de búfer.