Estoy trabajando en C, y tengo que concatenar algunas cosas.
Ahora mismo tengo esto:
message = strcat("TEXT ", var);
message2 = strcat(strcat("TEXT ", foo), strcat(" TEXT ", bar));
Ahora bien, si tienes experiencia en C estoy seguro de que te das cuenta de que esto te da un fallo de segmentación cuando intentas ejecutarlo. Entonces, ¿cómo puedo evitarlo?
En C, las "cadenas" son simplemente matrices char
. Por lo tanto, no puedes concatenarlas directamente con otras "cadenas".
Puedes utilizar la función strcat
, que añade la cadena apuntada por src
al final de la cadena apuntada por dest
:
char *strcat(char *dest, const char *src);
Aquí hay un ejemplo de cplusplus.com:
char str[80];
strcpy(str, "these ");
strcat(str, "strings ");
strcat(str, "are ");
strcat(str, "concatenated.");
Para el primer parámetro, es necesario proporcionar el propio buffer de destino. El búfer de destino debe ser un búfer de matriz de caracteres. Por ejemplo char buffer[1024];
Asegúrate de que el primer parámetro tiene suficiente espacio para almacenar lo que intentas copiar en él. Si está disponible, es más seguro utilizar funciones como strcpy_s
y strcat_s
donde tienes que especificar explícitamente el tamaño del buffer de destino.
Nota: Un literal de cadena no puede usarse como buffer, ya que es una constante. Por lo tanto, siempre hay que asignar un array de caracteres para el buffer.
El valor de retorno de strcat
puede ser simplemente ignorado, simplemente devuelve el mismo puntero que se pasó como primer argumento. Está ahí por comodidad, y permite encadenar las llamadas en una sola línea de código:
strcat(strcat(str, foo), bar);
Así que su problema podría ser resuelto de la siguiente manera:
char *foo = "foo";
char *bar = "bar";
char str[80];
strcpy(str, "TEXT ");
strcat(str, foo);
strcat(str, bar);
Es un comportamiento indefinido intentar modificar los literales de las cadenas, que es lo que hace algo como:
strcat ("Hello, ", name);
intentará hacer. Intentará añadir la cadena nombre
al final del literal de cadena "Hola, "
, que no está bien definido.
Intenta algo así. Consigue lo que parece que estás intentando hacer:
char message[1000];
strcpy (message, "TEXT ");
strcat (message, var);
Esto crea un área de búfer que está permitida para ser modificada y luego copia tanto el literal de la cadena como otro texto en ella. Sólo hay que tener cuidado con los desbordamientos del buffer. Si controlas los datos de entrada (o los compruebas de antemano), no pasa nada por utilizar búferes de longitud fija, como he hecho yo.
De lo contrario, deberías usar estrategias de mitigación como asignar suficiente memoria del heap para asegurarte de que puedes manejarlo. En otras palabras, algo como
const static char TEXT[] = "TEXT ";
// Make *sure* you have enough space.
char *message = malloc (sizeof(TEXT) + strlen(var) + 1);
if (message == NULL)
handleOutOfMemoryIntelligently();
strcpy (message, TEXT);
strcat (message, var);
// Need to free message at some point after you're done with it.
El primer argumento de strcat() tiene que tener espacio suficiente para la cadena concatenada. Por tanto, asigne un búfer con espacio suficiente para recibir el resultado.
char bigEnough[64] = "";
strcat(bigEnough, "TEXT");
strcat(bigEnough, foo);
/* and so on */
strcat() concatenará el segundo argumento con el primer argumento, y almacenará el resultado en el primer argumento, el char* devuelto es simplemente este primer argumento, y sólo para su conveniencia.
No obtienes una cadena recién asignada con el primer y segundo argumento concatenados, lo cual supongo que esperabas basándote en tu código.