strcat y strncat en C: ejercicio resuelto

Si buscas strcat y strncat en C ejercicio resuelto, aquí tienes los patrones esenciales: concatenar dos cadenas con strcat, concatenar con límite de seguridad usando strncat y construir cadenas paso a paso sin desbordamiento de buffer.

strncat(dst, src, n) añade como máximo n caracteres de src al final de dst y siempre termina la cadena con \0. El parámetro n es el número de caracteres a copiar de la fuente, no el tamaño total del destino.

Enunciado

Construye la cadena "Hola, mundo!" concatenando partes con strcat.
Repite el ejercicio con strncat limitando el número de caracteres añadidos.
Muestra cómo calcular correctamente el espacio restante antes de strncat.

Solución en C

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <string.h>

int main(void) {
    char buf[32];

    /* 1. strcat básico */
    strcpy(buf, "Hola");
    strcat(buf, ", ");
    strcat(buf, "mundo");
    strcat(buf, "!");
    printf("strcat:  \"%s\"\n", buf);

    /* 2. strncat con límite */
    char dst[16] = "C es ";
    strncat(dst, "genial y potente", 6); /* añade máximo 6 chars */
    printf("strncat: \"%s\"\n", dst);

    /* 3. Cálculo seguro del espacio restante */
    char resultado[20] = "";
    const char *partes[] = {"uno", "-", "dos", "-", "tres"};
    for (int i = 0; i < 5; i++) {
        size_t restante = sizeof(resultado) - strlen(resultado) - 1;
        strncat(resultado, partes[i], restante);
    }
    printf("seguro:  \"%s\"\n", resultado);

    return 0;
}

Resultado esperado

1
2
3
strcat:  "Hola, mundo!"
strncat: "C es genial"
seguro:  "uno-dos-tres"

Errores frecuentes

Pasar el tamaño total del buffer como n en strncat: el parámetro n es el número de caracteres a copiar de la fuente, no el espacio disponible. Para calcular el espacio real hay que restar strlen(dst) y el \0.
No reservar espacio suficiente en dst antes de strcat: si dst no tiene espacio, se produce un desbordamiento de buffer.
Confundir strncat con strncpy: strncat siempre agrega \0; strncpy no lo hace si n < strlen(src).
Encadenar muchos strcat en lugar de usar snprintf: snprintf es más eficiente y seguro para construir cadenas compuestas.

Aplicación práctica

strncat se usa para construir cadenas de forma incremental cuando se trabaja con buffers de tamaño fijo: construir rutas de sistema de ficheros, mensajes de protocolo o fragmentos de HTML. En código nuevo se prefiere snprintf para toda la cadena de una vez.

Siguiente ejercicio recomendado

Práctica guiada y libro completo

Si quieres una ruta completa con progresión real de dificultad:

FAQ

¿Cuál es la diferencia exacta entre `strcat` y `strncat`?

strcat(dst, src) copia todos los caracteres de src hasta el \0 inclusive al final de dst, sin límite. strncat(dst, src, n) copia como máximo n caracteres de src y siempre añade un \0 al final. La diferencia es de seguridad: strncat permite controlar cuánto se añade.

¿Por qué el parámetro `n` de `strncat` no es el tamaño del buffer destino?

Por diseño histórico de C. n indica cuántos caracteres se toman de la fuente. Para calcular el espacio realmente disponible en dst hay que calcular sizeof(dst) - strlen(dst) - 1 y pasar ese valor como n.

¿Cuándo es mejor usar `snprintf` en lugar de `strncat`?

Casi siempre. snprintf(buf, sizeof(buf), "%s%s", parte1, parte2) es más claro, más seguro y más eficiente que múltiples llamadas a strncat. Se prefiere strncat solo cuando se añade un fragmento a una cadena existente y el overhead de snprintf no es aceptable.

strcat y strncat en C: ejercicio resuelto