Ausführbare C-Docs: Strukturen

Q: Wie deklariert man eine Struktur in C?

Schreibe struct, gefolgt von einem Tag-Namen und einer geklammerten Liste von Elementen: struct Point { int x; int y; };. Das deklariert einen Typ, keine Variable. Um eine Variable zu erzeugen, schreibst du dann struct Point p; - das Wort struct gehört in C zum Typnamen, weshalb der meiste Code es mit einem typedef paart.

Q: Was ist der Unterschied zwischen `.` und `->` bei Strukturen?

Nimm ., wenn du die Struktur selbst hast (p.x), und ->, wenn du einen Zeiger darauf hast (ptr->x). Der Pfeil ist die Kurzform für (*ptr).x. Siehe Strukturen und Zeiger für die Einzelheiten.

Q: Wie initialisiere ich eine Struktur in C?

Entweder nach Position, struct Point p = {3, 4};, oder mit benannten Initialisierern, struct Point p = {.y = 4, .x = 3};. Die benannte Form nennt jedes Element und übersteht daher, dass jemand die Struktur später umsortiert, und lässt ungenannte Elemente genullt.

Ein Array hält viele Werte eines Typs. Eine struct tut das Gegenteil: Sie hält ein paar Werte verschiedener Typen und behandelt sie als ein Ding. Ein Punkt ist ein x und ein y. Ein Angestellter ist ein Name, eine Nummer und ein Gehalt. Ohne Strukturen würdest du diese als drei lose Variablen herumtragen und hoffen, nie zu verwechseln, wessen Gehalt wessen ist.

Einen Strukturtyp deklarieren

Eine Strukturdeklaration benennt ein Tag und listet die Elemente in geschweiften Klammern:

struct Point {
    int x;
    int y;
};

Das Semikolon nach der schließenden Klammer ist Pflicht - es zu vergessen erzeugt eine der verwirrendsten Fehlermeldungen, die ein C-Anfänger trifft, weil der Compiler die nächste Zeile beschuldigt.

Das deklariert einen Typ, keine Variable. In C lautet der vollständige Name des Typs struct Point, mit dem Schlüsselwort:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p;
    p.x = 3;
    p.y = 4;

    printf("(%d, %d)\n", p.x, p.y);
    return 0;
}

Elemente werden mit dem Punktoperator gelesen und geschrieben, p.x. Eine Strukturvariable ist eine gewöhnliche Variable: Sie liegt auf dem Stack, sie kann mit = einer anderen Struktur desselben Typs zugewiesen werden, und sie verschwindet am Ende ihres Gültigkeitsbereichs.

Überall struct Point zu schreiben ermüdet, weshalb fast jeder echte C-Code die Deklaration in ein typedef wickelt, sodass der Typ einfach Point heißt.

Eine Struktur initialisieren

Du kannst eine Struktur in dem Moment füllen, in dem du sie deklarierst. Die Positionsform listet Werte in der Deklarationsreihenfolge:

struct Point p = {3, 4};   // x = 3, y = 4

Der benannte Initialisierer nennt stattdessen jedes Element, was klarer und sicherer ist:

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee a = {101, "Ada", 92000.0};
    struct Employee b = {.name = "Grace", .id = 102, .salary = 105000.0};
    struct Employee blank = {0};

    printf("%d %s %.2f\n", a.id, a.name, a.salary);
    printf("%d %s %.2f\n", b.id, b.name, b.salary);
    printf("%d [%s] %.2f\n", blank.id, blank.name, blank.salary);
    return 0;
}

Drei bemerkenswerte Dinge:

Die benannte Form darf Elemente in beliebiger Reihenfolge aufführen, ein später hinzugefügtes oder umsortiertes Element schiebt Werte also nicht still in die falschen Plätze.
Jedes ausgelassene Element wird mit null initialisiert - {0} ist die idiomatische Art, eine ganze Struktur zu nullen.
Ein Element char name[32] ist ein echtes Array innerhalb der Struktur, die Zeichenkette wird also in der Struktur selbst gespeichert, nicht anderswo. Das bedeutet auch, dass a.name = "Ada"; nachträglich unerlaubt ist; du brauchst strcpy (siehe Zeichenkettenfunktionen).

Eine Struktur ohne Initialisierer ist uninitialisiert, und ihre Elemente zu lesen, bevor man sie schreibt, ist undefiniertes Verhalten. = {0} kostet nichts und beseitigt die ganze Fehlerkategorie.

Zuweisen und vergleichen

Die Strukturzuweisung kopiert jedes Element:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point a = {1, 2};
    struct Point b = a;   // vollstaendige Kopie

    b.x = 99;

    printf("a = (%d, %d)\n", a.x, a.y);
    printf("b = (%d, %d)\n", b.x, b.y);
    return 0;
}

a ist unberührt: b hat seine eigene Kopie bekommen. Beachte aber, was C dir nicht gibt - es gibt kein == für Strukturen. if (a == b) kompiliert nicht. Vergleichen heißt Elemente vergleichen:

if (a.x == b.x && a.y == b.y) { /* gleich */ }

Greife nicht als Abkürzung zu memcmp. Compiler fügen zwischen Elementen unsichtbare Füllbytes zur Ausrichtung ein, und diese Bytes können Müll enthalten, zwei Strukturen mit identischen Elementen können also Byte für Byte ungleich sein.

Arrays von Strukturen

Weil eine Struktur ein Typ wie jeder andere ist, kannst du ein Array davon anlegen - die übliche Art, eine Tabelle von Datensätzen zu halten.

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee staff[3] = {
        {101, "Ada",    92000.0},
        {102, "Grace",  105000.0},
        {103, "Alan",   87000.0},
    };

    int n = sizeof(staff) / sizeof(staff[0]);
    double total = 0.0;

    for (int i = 0; i < n; i++) {
        printf("%-3d %-8s %10.2f\n", staff[i].id, staff[i].name, staff[i].salary);
        total += staff[i].salary;
    }

    printf("Durchschnitt: %.2f\n", total / n);
    return 0;
}

staff[i].salary liest sich als „Element i, dann dessen Element salary" - das Indizieren bindet stärker als der Punkt, es braucht also keine Klammern.

Strukturen werden in Funktionen hineinkopiert

Das ist die Regel, die die Leute erwischt. Wenn du eine Struktur an eine Funktion übergibst, kopiert C sie. Die Funktion arbeitet auf ihrer eigenen privaten Kopie:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void try_to_move(struct Point p) {
    p.x += 100;   // aendert nur die Kopie
}

double distance_from_origin(struct Point p) {
    return p.x * p.x + p.y * p.y;   // quadrierter Abstand, kein math.h noetig
}

int main(void) {
    struct Point p = {3, 4};

    try_to_move(p);
    printf("nach try_to_move: (%d, %d)\n", p.x, p.y);
    printf("quadrierter Abstand: %.0f\n", distance_from_origin(p));
    return 0;
}

p ist weiterhin (3, 4). Eine Struktur als Wert zu lesen, wie distance_from_origin es tut, ist vollkommen in Ordnung und bei kleinen Strukturen oft die klarste Wahl. Muss die Funktion aber die Struktur des Aufrufers ändern - oder ist die Struktur groß genug, dass das Kopieren verschwenderisch ist -, übergib stattdessen einen Zeiger. Das ist das Thema von Strukturen und Zeiger.

Eine Struktur als Wert zurückzugeben funktioniert genauso und ist völlig erlaubt:

struct Point make_point(int x, int y) {
    struct Point p = {x, y};
    return p;
}

Verschachtelte Strukturen

Ein Strukturelement kann selbst eine Struktur sein. Verkette die Punkte, um hineinzugreifen:

#include <stdio.h>

struct Date {
    int year;
    int month;
    int day;
};

struct Book {
    char title[64];
    struct Date published;
    int pages;
};

int main(void) {
    struct Book b = {
        .title = "The C Programming Language",
        .published = {.year = 1978, .month = 2, .day = 22},
        .pages = 228,
    };

    printf("%s (%d-%02d-%02d), %d Seiten\n",
           b.title,
           b.published.year, b.published.month, b.published.day,
           b.pages);
    return 0;
}

b.published.year geht Ebene für Ebene hinein. Verschachtelung ist der Weg, in C echte Datenmodelle zu bauen - und die innere Struktur wird in der äußeren gespeichert, nicht nur angezeigt, das ganze Book ist also ein zusammenhängender Speicherblock.

Größe, Füllbytes und Elementreihenfolge

sizeof sagt dir, wie groß eine Struktur ist, und die Antwort ist oft größer als die Summe ihrer Elemente:

#include <stdio.h>

struct Wasteful {
    char  a;    // 1 Byte
    int   b;    // 4 Bytes
    char  c;    // 1 Byte
};

struct Tidy {
    int   b;
    char  a;
    char  c;
};

int main(void) {
    printf("Wasteful: %zu Bytes\n", sizeof(struct Wasteful));
    printf("Tidy:     %zu Bytes\n", sizeof(struct Tidy));
    return 0;
}

Auf einer typischen Maschine hat Wasteful 12 Bytes und Tidy 8, obwohl beide dieselben drei Elemente halten. Der Compiler fügt Füllbytes ein, damit jedes Element an einer Adresse sitzt, die seinem Typ gefällt - ein int will meist ein Vielfaches von 4. Größere Elemente vor kleineren zu gruppieren packt tendenziell besser.

Das zählt selten (ein Array mit einer Million Elementen, das Layout eines Netzpakets) und nie für die Korrektheit deines eigenen Codes. Was es erklärt, ist, warum sizeof dich überrascht und warum memcmp auf Strukturen eine schlechte Idee ist.

Häufig gestellte Fragen

Wie deklariert man eine Struktur in C?

Schreibe struct, gefolgt von einem Tag-Namen und einer geklammerten Liste von Elementen: struct Point { int x; int y; };. Das deklariert einen Typ, keine Variable. Um eine Variable zu erzeugen, schreibst du dann struct Point p; - das Wort struct gehört in C zum Typnamen, weshalb der meiste Code es mit einem typedef paart.

Was ist der Unterschied zwischen . und -> bei Strukturen?

Nimm ., wenn du die Struktur selbst hast (p.x), und ->, wenn du einen Zeiger darauf hast (ptr->x). Der Pfeil ist die Kurzform für (*ptr).x. Siehe Strukturen und Zeiger für die Einzelheiten.

Werden Strukturen in C als Wert oder als Referenz übergeben?

Als Wert, immer. Eine Struktur an eine Funktion zu übergeben kopiert jedes Element, Änderungen innerhalb der Funktion betreffen die Variable des Aufrufers also nicht. Um das Original zu ändern - oder um das Kopieren einer großen Struktur zu vermeiden - übergib stattdessen einen Zeiger.

Wie initialisiere ich eine Struktur in C?

Entweder nach Position, struct Point p = {3, 4};, oder mit benannten Initialisierern, struct Point p = {.y = 4, .x = 3};. Die benannte Form nennt jedes Element und übersteht daher, dass jemand die Struktur später umsortiert, und lässt ungenannte Elemente genullt.

Verwandte Konzepte