C Academy · Aula

memcpy e memset

Funções para memória bruta.

Aula 4 de 413 etapas

memcpy e memset é uma aula grátis de C Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.

Funções de memória bruta

Diferentemente das funções de string, memcpy e memset operam em bytes brutos e ignoram terminadores nulos.

Elas são declaradas em <string.h> e operam sobre uma quantidade de bytes especificada por você, o que as torna genéricas para qualquer tipo de dado.

#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;
}

A assinatura de memcpy

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

Ela copia exatamente n bytes de src para dest e retorna dest. Use sizeof para obter a quantidade correta 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;
}

Contando bytes corretamente

A quantidade é expressa em bytes, não em elementos. Para um vetor de int, você deve multiplicar por sizeof(int).

Usar sizeof(array) em um vetor real fornece automaticamente o tamanho total em 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;
}

As regiões não podem se sobrepor

memcpy tem comportamento indefinido se as regiões de origem e destino se sobrepuserem.

Quando os intervalos podem se sobrepor (por exemplo, ao deslocar elementos dentro de um vetor), use memmove, que trata a sobreposição com segurança.

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

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

A assinatura de memset

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

Ela preenche n bytes em ptr com o byte value. O valor é interpretado como um unsigned char, portanto apenas os 8 bits menos significativos importam.

#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;
}

Zerando a memória

O uso mais comum de memset é limpar um buffer ou uma estrutura, preenchendo-a com zeros antes do uso.

memset(arr, 0, sizeof(arr)) define todos os bytes como 0, o que é um zero válido para inteiros, números de ponto flutuante e ponteiros.

#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

Tenha cuidado: memset define cada byte, não cada elemento. Usá-la para preencher um vetor de int com o valor 1 NÃO produz valores um.

Cada int terá todos os bytes definidos como 0x01, resultando em 0x01010101, não em 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;
}

Limpando uma estrutura

memset é útil para inicializar uma estrutura inteira com zero em uma única chamada, em vez de definir 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;
}

Copiando estruturas

Você pode copiar uma estrutura com memcpy, embora uma atribuição simples (b = a;) geralmente faça a mesma coisa de forma mais clara.

memcpy é preferível ao copiar por meio de ponteiros genéricos void *, nos quais os tipos são apagados.

#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: comparando memória

Uma função relacionada, memcmp(a, b, n), compara n bytes brutos e retorna 0 se eles forem iguais.

Diferentemente de strcmp, ela não para em um terminador nulo, portanto funciona com qualquer dado binário.

#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 que são rápidas

memcpy e memset geralmente são otimizadas manualmente em assembly para mover muitos bytes por instrução.

Elas costumam ser muito mais rápidas que um laço de bytes escrito manualmente; portanto, prefira-as para movimentação e inicialização de grandes quantidades de dados.

#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;
}

Verificação rápida

Teste sua compreensão do comportamento de memset no nível dos bytes.

Responda na aula interativa

Revisão

Você aprendeu as funções de memória bruta:

memcpy copia n bytes; as regiões não podem se sobrepor (use memmove se isso puder acontecer).
memset preenche n bytes com um único valor de byte; é excelente para zerar dados.
As quantidades são expressas em bytes — use sizeof e tenha cuidado com as diferenças entre bytes e elementos.
memcmp compara bytes brutos sem parar em '\0'.

Grátis para começar

Aprenda C com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 39
Aulas: 144

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “memcpy e memset” é grátis?

Sim — o texto completo de “memcpy e memset” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.

O que vou aprender em “memcpy e memset”?

Funções para memória bruta. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C Academy?

Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “memcpy e memset”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C Academy?

Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C Academy