C Academy · Leçon

memcpy et memset

Fonctions de mémoire brute

memcpy et memset est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.

Fonctions de mémoire brute

Contrairement aux fonctions de traitement des chaînes, memcpy et memset agissent sur des octets bruts et ignorent les terminateurs nuls.

Elles sont déclarées dans <string.h> et fonctionnent avec un nombre d’octets que vous indiquez, ce qui les rend polyvalentes pour tout type de données.

#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 signature de memcpy

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

Elle copie exactement n octets de src vers dest et renvoie dest. Utilisez sizeof pour obtenir le nombre d’octets approprié.

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

Compter correctement les octets

Le nombre indiqué est exprimé en octets, et non en éléments. Pour un tableau de int, vous devez multiplier par sizeof(int).

Utiliser sizeof(array) sur un véritable tableau donne automatiquement sa taille totale en octets.

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

Les régions ne doivent pas se chevaucher

memcpy a un comportement indéfini si les régions source et destination se chevauchent.

Lorsque les plages peuvent se chevaucher, par exemple lors du décalage d’éléments dans un même tableau, utilisez plutôt memmove, qui gère correctement ce chevauchement.

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

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

La signature de memset

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

Elle remplit n octets à partir de ptr avec l’octet value. La valeur est interprétée comme un unsigned char ; seuls les 8 bits de poids faible comptent donc.

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

Mettre la mémoire à zéro

L’utilisation la plus courante de memset consiste à effacer un tampon ou une structure en mettant tous ses octets à zéro avant son utilisation.

memset(arr, 0, sizeof(arr)) définit chaque octet à 0, ce qui constitue une représentation valide de zéro pour les entiers, les nombres flottants et les pointeurs.

#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 fonctionne octet par octet

Soyez prudent : memset définit chaque octet, et non chaque élément. L’utiliser pour remplir un tableau d’entiers avec la valeur 1 ne produit PAS des uns.

Chaque int aurait tous ses octets définis à 0x01, ce qui donnerait 0x01010101, et non 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;
}

Effacer une structure

memset est pratique pour initialiser toute une structure à zéro en un seul appel, au lieu de définir chaque champ manuellement.

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

Copier des structures

Vous pouvez copier une structure avec memcpy, même si une simple affectation (b = a;) fait généralement la même chose plus clairement.

memcpy est préférable lors d’une copie via des pointeurs génériques void *, lorsque les types ont été effacés.

#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 : comparer la mémoire

Une fonction apparentée, memcmp(a, b, n), compare n octets bruts et renvoie 0 s’ils sont identiques.

Contrairement à strcmp, elle ne s’arrête pas à un terminateur nul et fonctionne donc avec toutes les données binaires.

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

Pourquoi ces fonctions sont rapides

memcpy et memset sont souvent optimisées manuellement en assembleur afin de déplacer de nombreux octets par instruction.

Elles sont généralement bien plus rapides qu’une boucle sur les octets écrite manuellement ; préférez-les donc pour déplacer et initialiser de grandes quantités de données.

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

Vérification rapide

Vérifiez votre compréhension du fonctionnement de memset au niveau des octets.

Récapitulatif

Vous avez découvert les fonctions de mémoire brute :

memcpy copie n octets ; les régions ne doivent pas se chevaucher (utilisez memmove si elles risquent de le faire).
memset remplit n octets avec une seule valeur d’octet ; elle est idéale pour mettre la mémoire à zéro.
Les quantités sont exprimées en octets — utilisez sizeof et méfiez-vous des pièges liés à la différence entre octets et éléments.
memcmp compare des octets bruts sans s’arrêter à '\0'.

Questions Fréquemment Posées

La leçon « memcpy et memset » est-elle gratuite ?

Oui — le texte complet de « memcpy et memset » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « memcpy et memset » ?

Fonctions de mémoire brute Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C Academy ?

Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « memcpy et memset » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C Academy ?

Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C Academy