C Academy · Lección

memcpy y memset

Funciones de memoria sin procesar

Lección 4 de 413 pasos

memcpy y memset es una lección gratuita de C Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

Funciones para memoria sin procesar

A diferencia de las funciones para cadenas, memcpy y memset trabajan con bytes sin procesar e ignoran los terminadores nulos.

Se declaran en <string.h> y operan sobre una cantidad de bytes que usted especifica, por lo que sirven para cualquier tipo de datos.

#include <stdio.h>
#include <string.h>

int main(void) {
    int src[] = {1, 2, 3};
    int dest[3];
    memcpy(dest, src, sizeof(src));
    printf("%d %d %d\n", dest[0], dest[1], dest[2]);
    return 0;
}

La firma de memcpy

void *memcpy(void *dest, const void *src, size_t n);

Copia exactamente n bytes de src a dest y devuelve dest. Use sizeof para obtener la cantidad correcta de bytes.

#include <stdio.h>
#include <string.h>

int main(void) {
    char src[] = "copy me";
    char dest[16];
    memcpy(dest, src, strlen(src) + 1);
    printf("%s\n", dest);
    return 0;
}

Contar bytes correctamente

La cantidad se expresa en bytes, no en elementos. Para una matriz de int, debe multiplicar por sizeof(int).

Usar sizeof(array) sobre una matriz real proporciona automáticamente su tamaño total en bytes.

#include <stdio.h>
#include <string.h>

int main(void) {
    double a[4] = {1.5, 2.5, 3.5, 4.5};
    double b[4];
    memcpy(b, a, 4 * sizeof(double));
    printf("%.1f %.1f\n", b[0], b[3]);
    return 0;
}

Las regiones no deben solaparse

memcpy tiene un comportamiento indefinido si las regiones de origen y destino se solapan.

Cuando los rangos puedan solaparse (por ejemplo, al desplazar elementos dentro de una misma matriz), use memmove, que gestiona el solapamiento de forma segura.

#include <stdio.h>
#include <string.h>

int main(void) {
    char buf[] = "ABCDEF";
    memmove(buf + 2, buf, 4);
    printf("%s\n", buf);
    return 0;
}

La firma de memset

void *memset(void *ptr, int value, size_t n);

Rellena n bytes en ptr con el byte value. El valor se interpreta como un unsigned char, por lo que solo importan los 8 bits inferiores.

#include <stdio.h>
#include <string.h>

int main(void) {
    char buf[6];
    memset(buf, 'x', 5);
    buf[5] = '\0';
    printf("%s\n", buf);
    return 0;
}

Poner la memoria a cero

El uso más habitual de memset es borrar un búfer o una estructura, dejándolos completamente a cero antes de utilizarlos.

memset(arr, 0, sizeof(arr)) establece todos los bytes en 0, que es un cero válido para enteros, números de coma flotante y punteros.

#include <stdio.h>
#include <string.h>

int main(void) {
    int counts[5];
    memset(counts, 0, sizeof(counts));
    for (int i = 0; i < 5; i++) printf("%d ", counts[i]);
    printf("\n");
    return 0;
}

memset funciona byte a byte

Tenga cuidado: memset establece cada byte, no cada elemento. Usarlo para rellenar una matriz de enteros con el valor 1 NO produce unos.

Cada entero tendría todos sus bytes establecidos en 0x01, lo que daría 0x01010101, no 1.

#include <stdio.h>
#include <string.h>

int main(void) {
    int a[2];
    memset(a, 1, sizeof(a));
    printf("%d\n", a[0]);
    return 0;
}

Borrar una estructura

memset resulta práctico para inicializar una estructura completa a cero en una sola llamada, en lugar de establecer cada campo manualmente.

#include <stdio.h>
#include <string.h>

struct Point { int x; int y; int z; };

int main(void) {
    struct Point p;
    memset(&p, 0, sizeof(p));
    printf("%d %d %d\n", p.x, p.y, p.z);
    return 0;
}

Copiar estructuras

Puede copiar una estructura con memcpy, aunque la asignación directa (b = a;) normalmente hace lo mismo de forma más clara.

memcpy se prefiere al copiar mediante punteros genéricos void *, cuyos tipos se han eliminado.

#include <stdio.h>
#include <string.h>

struct Rec { int id; char tag; };

int main(void) {
    struct Rec a = {42, 'A'};
    struct Rec b;
    memcpy(&b, &a, sizeof(a));
    printf("%d %c\n", b.id, b.tag);
    return 0;
}

memcmp: comparar memoria

Una función relacionada, memcmp(a, b, n), compara n bytes sin procesar y devuelve 0 si coinciden.

A diferencia de strcmp, no se detiene ante un terminador nulo, por lo que funciona con cualquier dato binario.

#include <stdio.h>
#include <string.h>

int main(void) {
    int a[] = {1, 2, 3};
    int b[] = {1, 2, 3};
    if (memcmp(a, b, sizeof(a)) == 0)
        printf("Arrays have identical bytes\n");
    return 0;
}

Por qué son rápidas

memcpy y memset suelen estar optimizadas manualmente en ensamblador para mover muchos bytes por instrucción.

Normalmente son mucho más rápidas que un bucle de bytes escrito a mano, así que prefiera usarlas para mover e inicializar grandes cantidades de datos.

#include <stdio.h>
#include <string.h>

int main(void) {
    char big[1000];
    memset(big, 0, sizeof(big));
    printf("Cleared %lu bytes\n", sizeof(big));
    return 0;
}

Comprobación rápida

Compruebe cuánto entiende sobre el funcionamiento de memset a nivel de bytes.

Responde en la lección interactiva

Repaso

Ha aprendido las funciones para trabajar con memoria sin procesar:

memcpy copia n bytes; las regiones no deben solaparse (use memmove si pueden hacerlo).
memset rellena n bytes con un único valor de byte; es excelente para poner la memoria a cero.
Las cantidades se expresan en bytes: use sizeof y tenga cuidado con las diferencias entre bytes y elementos.
memcmp compara bytes sin procesar sin detenerse ante '\0'.

Gratis para empezar

Aprende C con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 39
Lecciones: 144

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «memcpy y memset» es gratis?

Sí — el texto completo de «memcpy y memset» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «memcpy y memset»?

Funciones de memoria sin procesar Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «memcpy y memset»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C Academy