0Pricing
C Academy · Lektion

memcpy und memset

Funktionen für rohen Speicher

memcpy und memset ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Funktionen für den Zugriff auf Rohspeicher

Im Gegensatz zu Zeichenkettenfunktionen arbeiten memcpy und memset mit rohen Bytes und ignorieren Nullterminatoren.

Sie sind in <string.h> deklariert und arbeiten mit einer von Ihnen angegebenen Anzahl von Bytes. Dadurch eignen sie sich für jeden Datentyp.

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

Die Signatur von memcpy

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

Die Funktion kopiert genau n Bytes von src nach dest und gibt dest zurück. Verwenden Sie sizeof, um die richtige Byteanzahl zu ermitteln.

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

Bytes korrekt zählen

Die Anzahl wird in Bytes angegeben, nicht in Elementen. Bei einem Array aus int müssen Sie mit sizeof(int) multiplizieren.

Bei einem echten Array liefert sizeof(array) automatisch die gesamte Größe in 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;
}

Bereiche dürfen sich nicht überschneiden

memcpy führt zu undefiniertem Verhalten, wenn sich Quell- und Zielbereich überschneiden.

Wenn sich Bereiche möglicherweise überschneiden, etwa beim Verschieben von Elementen innerhalb eines Arrays, verwenden Sie stattdessen memmove, das Überschneidungen sicher behandelt.

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

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

Die Signatur von memset

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

Die Funktion füllt bei ptr n Bytes mit dem Bytewert value. Der Wert wird als unsigned char interpretiert, daher sind nur die niedrigsten 8 Bits relevant.

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

Speicher auf null setzen

Am häufigsten wird memset verwendet, um einen Puffer oder ein Struct vor der Verwendung vollständig mit Nullen zu füllen.

memset(arr, 0, sizeof(arr)) setzt jedes Byte auf 0. Das ist ein gültiger Nullwert für Integer, Gleitkommazahlen und Zeiger.

#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 arbeitet Byte für Byte

Seien Sie vorsichtig: memset setzt jedes Byte, nicht jedes Element. Wenn Sie damit ein int-Array mit dem Wert 1 füllen, erhalten Sie NICHT lauter Einsen.

Bei jedem int würde jedes Byte auf 0x01 gesetzt, was 0x01010101 statt 1 ergibt.

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

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

Ein Struct leeren

memset ist praktisch, um ein gesamtes Struct mit einem einzigen Aufruf auf null zu setzen, anstatt jedes Feld einzeln zu initialisieren.

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

Structs kopieren

Sie können ein Struct mit memcpy kopieren. Eine einfache Zuweisung (b = a;) erledigt dies jedoch meist verständlicher.

memcpy wird bevorzugt, wenn über generische void *-Zeiger kopiert wird und die Typen nicht mehr bekannt sind.

#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: Speicher vergleichen

Eine verwandte Funktion, memcmp(a, b, n), vergleicht n rohe Bytes und gibt bei Übereinstimmung 0 zurück.

Anders als strcmp stoppt sie nicht am Nullterminator und funktioniert daher mit beliebigen Binärdaten.

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

Warum diese Funktionen schnell sind

memcpy und memset werden häufig in Assembly von Hand optimiert, um viele Bytes pro Instruktion zu verarbeiten.

Sie sind normalerweise deutlich schneller als eine selbst geschriebene Byte-Schleife. Verwenden Sie sie daher zum Verschieben und Initialisieren größerer Datenmengen.

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

Schnelltest

Testen Sie Ihr Verständnis der byteweisen Funktionsweise von memset.

Zusammenfassung

Sie haben die Funktionen für den Zugriff auf Rohspeicher kennengelernt:

  • memcpy kopiert n Bytes; die Bereiche dürfen sich nicht überschneiden (verwenden Sie memmove, wenn dies möglich ist).
  • memset füllt n Bytes mit einem Bytewert und eignet sich besonders zum Setzen auf null.
  • Die Anzahl wird in Bytes angegeben — verwenden Sie sizeof und achten Sie auf den Unterschied zwischen Bytes und Elementen.
  • memcmp vergleicht rohe Bytes, ohne bei '\0' anzuhalten.

Häufig gestellte Fragen

Ist die Lektion „memcpy und memset“ kostenlos?

Ja — der vollständige Text von „memcpy und memset“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „memcpy und memset“?

Funktionen für rohen Speicher Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „memcpy und memset“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. strlen, strcpy, strcat
  2. strcmp und Vergleiche
  3. strtok und Tokenizing
  4. memcpy und memset
← Zurück zu C Academy