Manipular texto sin herirte

La respuesta popular a los desbordamientos fue añadir una n al nombre de las funciones peligrosas. Fue una respuesta incompleta y en algunos casos contraproducente: strncpy no es strcpy con límite, strncat no cuenta lo que crees que cuenta, y el Anexo K que iba a resolverlo todo apenas se implementó fuera de Windows. La salida no está en memorizar cuál de las variantes es la buena, sino en adoptar una disciplina: toda operación sobre texto recibe la capacidad del destino, garantiza el terminador y te dice si truncó. Este capítulo construye esa disciplina y las herramientas para sostenerla.

strncpy no es strcpy con límite

strncpy se diseñó en los setenta para rellenar campos de longitud fija en entradas de directorio de UNIX, no para copiar cadenas con seguridad. Su comportamiento delata ese origen:

char d[8];

strncpy(d, "hola", sizeof d);
/* Trampa 1: RELLENA el resto con ceros -> escribe los 8 bytes siempre */

strncpy(d, "una cadena larga", sizeof d);
/* Trampa 2: NO termina el destino -> d queda sin '\0' */

Las dos consecuencias son graves en direcciones opuestas. La primera es un coste oculto: copiar un nombre de cuatro letras a un buffer de cuatro kilobytes escribe cuatro kilobytes. La segunda es un fallo de corrección: si el origen tiene al menos tantos caracteres como la capacidad, el destino no queda terminado y la siguiente lectura se sale del buffer.

strncat es peor de entender, porque su n no es la capacidad del destino sino el número máximo de caracteres a añadir, y además escribe siempre un terminador adicional. La expresión correcta es incómoda y por eso casi nadie la escribe bien:

strncat(d, origen, sizeof d - strlen(d) - 1);
/* si strlen(d) ya vale sizeof d, la resta se desborda como size_t */

snprintf: la herramienta por defecto

snprintf resuelve de una vez los tres problemas: acota la escritura a la capacidad, siempre termina el destino y devuelve información suficiente para detectar el truncado.

char ruta[64];
int r = snprintf(ruta, sizeof ruta, "%s/%s.log", dir, nombre);

if (r < 0)                  { /* error de codificacion */ }
else if ((size_t)r >= sizeof ruta) { /* TRUNCADO: r es lo que HABRIA escrito */ }

La clave está en el valor de retorno: no es lo que escribió, es lo que habría escrito si hubiera cabido, sin contar el terminador. Comparar ese número con la capacidad es la comprobación de truncado, y es la razón por la que snprintf domina sobre todas las variantes de strcpy.

Ese mismo contrato da el idioma de dos pasadas para dimensionar un buffer exacto:

int n = snprintf(nullptr, 0, "%s=%d", clave, valor);   /* solo mide */
char *s = malloc((size_t)n + 1);
if (s) snprintf(s, (size_t)n + 1, "%s=%d", clave, valor);

El zoo de alternativas

De todas ellas, memccpy es la que más gente desconoce y la que mejor encaja con la disciplina de este capítulo, porque el propio valor de retorno distingue los dos desenlaces sin cálculos adicionales:

/* Copia acotada con deteccion de truncado, todo en C23 estandar */
char *fin = memccpy(dst, src, '\0', cap);
if (fin == nullptr) {
    dst[cap - 1] = '\0';   /* no cupo: truncamos de forma explicita */
    /* ...tratar el truncado... */
}

Compáralo con strncpy: misma cota, ningún relleno, y una respuesta clara a la única pregunta que importa. La diferencia entre una API segura y una insegura casi nunca está en lo que hace, sino en lo que te permite saber.

Tus propias utilidades

La solución de fondo es dejar de tratar el texto como “puntero a char” y empezar a tratarlo como “puntero más capacidad”, con el truncado como resultado explícito y no como accidente silencioso.

/* Copia acotada: termina siempre y avisa si trunco */
bool copia_str(char *dst, size_t cap, const char *src) {
    if (cap == 0) return false;
    size_t n = strlen(src);
    size_t k = (n < cap - 1) ? n : cap - 1;
    memcpy(dst, src, k);
    dst[k] = '\0';
    return n < cap;                 /* false si hubo truncado */
}

/* Escritor con cursor: componer sin recorrer lo ya escrito */
struct escritor { char *buf; size_t cap, pos; bool desbordado; };

void esc_add(struct escritor *e, const char *txt) {
    if (e->desbordado || e->pos >= e->cap) { e->desbordado = true; return; }
    int r = snprintf(e->buf + e->pos, e->cap - e->pos, "%s", txt);
    if (r < 0 || (size_t)r >= e->cap - e->pos) { e->desbordado = true; return; }
    e->pos += (size_t)r;
}

flowchart TD
A[Necesito escribir texto en un buffer] --> B[Conozco la capacidad del destino]
B --> C[Formateo con partes variables]
B --> D[Copia simple de una cadena]
C --> E[snprintf y comprobar el retorno]
D --> F[memcpy con longitud y terminador explicito]
E --> G[Truncado detectado y tratado]
F --> G
G --> H[Invariante: el destino siempre termina]
style H fill:#a6e3a1,color:#11111b