Guía para copiar arrays en C: memcpy vs bucle for vs strcpy

1. Introducción

La importancia de la “copia de arreglos” en C

Muchos luchan con la copia de arreglos

• ¿Puedes copiar instantáneamente usando memcpy?
• ¿Cuál es la diferencia con strcpy?
• ¿Es más seguro copiar un elemento a la vez con un for loop?
• ¿Cómo escribes una copia usando punteros?

Lo que aprenderás en este artículo

• Conceptos fundamentales de los arreglos en C
• Múltiples formas de copiar arreglos, junto con sus ventajas y precauciones
• Consejos y trampas al copiar cadenas (arreglos de char)
• Explicaciones en estilo Q&A para preguntas comunes

2. Conceptos básicos de los arreglos

¿Qué es un arreglo?

int scores[5];

scores[0] = 80;
scores[1] = 75;
scores[2] = 90;
scores[3] = 60;
scores[4] = 85;

Cómo inicializar un arreglo

int scores[5] = {80, 75, 90, 60, 85};

int scores[] = {80, 75, 90, 60, 85};  // El número de elementos se determina automáticamente como 5

int scores[5] = {80, 75};  // scores[2] a través de scores[4] se convierten en 0

Entendiendo la disposición en memoria de los arreglos

for (int i = 0; i < 5; i++) {
    printf("%d\n", scores[i]);
}

3. Cómo copiar arrays

int a[5] = {1, 2, 3, 4, 5};
int b[5];
b = a;  // Error: no se permite asignar un array a otro

Copiar elementos con un bucle for

#include 

int main() {
    int src[5] = {10, 20, 30, 40, 50};
    int dest[5];

    for (int i = 0; i < 5; i++) {
        dest[i] = src[i];
    }

    // Mostrar el resultado de la copia
    for (int i = 0; i < 5; i++) {
        printf("%d ", dest[i]);
    }

    return 0;
}

Función memcpy para copia rápida

#include 
#include 

int main() {
    int src[5] = {1, 2, 3, 4, 5};
    int dest[5];

    memcpy(dest, src, sizeof(src));  // Copiar el número de bytes en src

    for (int i = 0; i < 5; i++) {
        printf("%d ", dest[i]);
    }

    return 0;
}

Consejos de uso de memcpy:

• Primer argumento: puntero de destino
• Segundo argumento: puntero de origen
• Tercer argumento: número de bytes a copiar (nota: no el conteo de elementos)

Precauciones:

• Si los tamaños de los arrays de origen y destino difieren, hay riesgo dedesbordamiento de búfer, por lo que siempre verifique los tamaños.
• No lo use cuando las regiones de memoria se superpongan (explicado en la siguiente sección).

Diferencias y cuándo usar memmove

• memcpy:Use cuando la memoria no se superpone. La superposición lleva a un comportamiento indefinido.
• memmove:Puede copiar de manera segura incluso cuando se superpone.

Ejemplo:

char str[] = "ABCDE";

// Copia de sobrescritura desde el primer carácter a los caracteres segundo y siguientes (superposición)
memmove(str + 1, str, 4);
str[5] = ' ';  // terminador nulo

printf("%s\n", str);  // Salida: AABCD

Regla básica para elegir:

4. Copia de cadenas (arreglos char)

strcpy Función para copiar cadenas

#include 
#include 

int main() {
    char src[] = "¡Hola, mundo!";
    char dest[50];

    strcpy(dest, src);

    printf("Resultado de la copia: %sn", dest);

    return 0;
}

Notas:

• Si el tamaño de dest es demasiado pequeño, puede causar undesbordamiento de búfer, por lo que debes asegurarte de que sea suficiente.
• El número de caracteres copiados depende de la longitud de src.

strncpy para copia segura

#include 
#include 

int main() {
    char src[] = "lenguaje C";
    char dest[10];

    strncpy(dest, src, sizeof(dest) - 1);  // Keep the last byte for the null terminator
    dest[9] = ' ';  // Explicitly set terminator for safety

    printf("Resultado de la copia: %sn", dest);

    return 0;
}

Características de strncpy:

• Copia solo la longitud especificada.
• Si la fuente es más corta, la parte restante se rellena con NULL (definido por la implementación).
• El carácter de terminación no se garantiza que se agregue automáticamente, por lo que configurarlo explícitamente tú mismo es más seguro.

Precaución al manejar japonés (cadenas multibyte)

Resumen de las mejores prácticas para la copia de cadenas

5. Precauciones al copiar arreglos

Cuidado con los desbordamientos de búfer

Ejemplo: Operación de copia peligrosa

char src[] = "Esta es una cadena larga.";
char dest[10];

strcpy(dest, src);  // La copia excede el tamaño de dest → posible corrupción de memoria

Contramedidas:

• strncpy o memcpy deben usarse,siempre limitando el tamaño.
• Recuerda agregar manualmente el carácter nulo terminador.
• Gestiona los tamaños de los arreglos usando constantes o macros.

Determina con precisión el tamaño del objetivo de copia

Ejemplo de especificación de tamaño segura:

int src[5] = {1, 2, 3, 4, 5};
int dest[5];

memcpy(dest, src, sizeof(src));  // especifica el tamaño total en bytes de src

Precauciones al trabajar con punteros

Ejemplo de error común:

int *src = NULL;
int dest[5];

memcpy(dest, src, sizeof(dest));  // usando un puntero NULL como fuente → fallo

Puntos clave:

• Verifica que el puntero referencie una dirección válida, realizando unaverificación de NULL.
• Si copias después de la asignación de memoria (p. ej., malloc), verifica laconsistencia entre el tamaño asignado y el tamaño de copia.

Manejo de regiones de origen y destino superpuestas

char buffer[100] = "ejemplo";

// mueve una porción de la cadena dentro de sí misma
memmove(buffer + 2, buffer, 4);  // copia de manera segura datos superpuestos

Definición y gestión de tamaños de arreglos

#define ARRAY_SIZE 10

int arr1[ARRAY_SIZE];
int arr2[ARRAY_SIZE];

memcpy(arr2, arr1, sizeof(arr1));

Resumen para la copia segura de arreglos

• Al copiar,determina con precisión el tamaño (en bytes).
• Elige funciones seguras como strncpy o memmove.
• Verifica siempre laconsistencia de tamaño entre origen y destino.
• Ten especial cuidado con las operaciones de punteros, realizando verificaciones de NULL y de límites.

6. Preguntas frecuentes (FAQ)

Q1. ¿Cuál es la diferencia entre memcpy y memmove?

Q2. ¿Cuáles son las diferencias entre strcpy y strncpy, y cómo deben usarse?

• strcpy(dest, src) → Copia todo hasta el null terminador de src.Sin embargo, si dest es demasiado pequeño, puede ocurrir un desbordamiento de búfer.
• strncpy(dest, src, n) → Copia como máximo el número especificado de bytes n.La seguridad es mayor, pero la terminación null no está garantizada automáticamente.

• Si estás seguro de que el tamaño es suficiente, usa strcpy
• Cuando la seguridad es primordial o al manejar cadenas arbitrarias, usa strncpy y agrega manualmente el terminador null

Q3. ¿Hay alguna precaución al pasar un array como argumento de función?

void copy_array(int arr[], int size) {
    printf("%zun", sizeof(arr));  // ← se convierte en el tamaño de un puntero (por ejemplo, 8)
}

void copy_array(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        // lógica de procesamiento
    }
}

Q4. ¿Está bien copiar un array de structs con memcpy?

Ejemplo (resulta en una copia superficial):

typedef struct {
    char *name;
    int age;
} Person;

Person a[3];
Person b[3];

memcpy(b, a, sizeof(a));  // copia los punteros mismos (los datos apuntados se comparten)

Q5. Quiero copiar arrays en masa, pero escribir un bucle for cada vez es tedioso. ¿Puedo hacer una función común?

void copy_int_array(int *dest, int *src, int size) {
    for (int i = 0; i < size; i++) {
        dest[i] = src[i];
    }
}

7. Resumen

Conceptos básicos de copia de arreglos: seguridad y propósito claro

• bucle for: el más básico y directo. Necesitas especificar el tamaño del arreglo.
• memcpy: copia rápida a nivel binario. Ten cuidado con las discrepancias de tamaño.
• memmove: úsalo cuando el origen y el destino se superpongan.
• strcpy / strncpy: funciones para cadenas (arreglos de char). Elige según consideraciones de seguridad.

La copia segura requiere un manejo adecuado del tamaño

• El tamaño del arregloexcedido (copia excesiva)puede causar fallos y vulnerabilidades.
• Usar sizeof() paradeterminar el número exacto de byteses importante.
• Al manejar arreglos en funciones, entiende quese degradan a punterosy pasa el tamaño como argumento también.

Entiende las trampas comunes

• strncpy es seguro peropuede no terminar con null, así que adquiere el hábito de agregar el terminador manualmente.
• Los arreglos que contienenpunteros a estructuraspueden no copiarse correctamente con memcpy.
• Al tratar con cadenas multibyte (por ejemplo, japonés), ten en cuenta la diferencia entreconteo de caracteres y conteo de bytes.

Aplícalo en la práctica

• Si la copia de arreglos ocurre con frecuencia en un proyecto, es útil crear unafunción de utilidad dedicada.
• Las operaciones de copia son unaunidad bien aislada para pruebas, por lo que se recomienda verificar la seguridad con pruebas unitarias.

Finalmente