Docs C exécutables : structures

Q: Comment déclare-t-on une structure en C ?

Écrivez struct suivi d'un nom d'étiquette et d'une liste de membres entre accolades : struct Point { int x; int y; };. Cela déclare un type, pas une variable. Pour créer une variable, vous écrivez ensuite struct Point p; - le mot struct fait partie du nom du type en C, c'est pourquoi la plupart du code l'associe à un typedef.

Q: Quelle est la différence entre `.` et `->` pour les structures ?

Utilisez . quand vous avez la structure elle-même (p.x) et -> quand vous avez un pointeur dessus (ptr->x). La flèche est un raccourci pour (*ptr).x. Voir structures et pointeurs pour les détails.

Q: Comment initialiser une structure en C ?

Soit par position, struct Point p = {3, 4};, soit avec des initialiseurs désignés, struct Point p = {.y = 4, .x = 3};. La forme désignée nomme chaque membre, elle survit donc à un réordonnancement ultérieur de la structure et laisse à zéro les membres non nommés.

Un tableau contient plusieurs valeurs d'un seul type. Une struct fait l'inverse : elle contient quelques valeurs de types différents et les traite comme une seule chose. Un point, c'est un x et un y. Un employé, c'est un nom, un identifiant et un salaire. Sans structures, vous trimballeriez cela comme trois variables éparses en espérant ne jamais mélanger le salaire de l'un avec celui de l'autre.

Déclarer un type structure

Une déclaration de structure nomme une étiquette et liste les membres entre accolades :

struct Point {
    int x;
    int y;
};

Le point-virgule après l'accolade fermante est obligatoire - l'oublier est l'un des messages d'erreur les plus déroutants qu'un débutant en C rencontrera, car le compilateur accuse la ligne suivante.

Cela déclare un type, pas une variable. En C, le nom complet du type est struct Point, mot-clé compris :

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

Les membres se lisent et s'écrivent avec l'opérateur point, p.x. Une variable structure est une variable ordinaire : elle vit sur la pile, peut être affectée à une autre structure du même type avec =, et disparaît à la fin de sa portée.

Écrire struct Point partout devient fatigant, c'est pourquoi presque tout le vrai code C enveloppe la déclaration dans un typedef pour que le type soit simplement Point.

Initialiser une structure

Vous pouvez remplir une structure au moment où vous la déclarez. La forme positionnelle liste les valeurs dans l'ordre de déclaration :

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

L'initialiseur désigné nomme chaque membre à la place, ce qui est plus clair et plus sûr :

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

Trois choses à remarquer :

La forme désignée peut lister les membres dans n'importe quel ordre, donc ajouter ou réordonner un membre plus tard ne décale pas silencieusement les valeurs dans les mauvaises cases.
Tout membre omis est initialisé à zéro - {0} est la façon idiomatique de mettre à zéro une structure entière.
Un membre char name[32] est un vrai tableau dans la structure, donc la chaîne est stockée dans la structure elle-même, pas ailleurs. Cela signifie aussi que a.name = "Ada"; après coup est illégal ; il vous faut strcpy (voir fonctions de chaînes).

Une structure sans initialiseur n'est pas initialisée, et lire ses membres avant de les écrire est un comportement indéfini. = {0} ne coûte rien et supprime toute la catégorie de bug.

Affecter et comparer

L'affectation de structure copie chaque membre :

#include <stdio.h>

struct Point {
    int x;
    int y;
};

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

    b.x = 99;

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

a est intacte : b a reçu sa propre copie. Mais notez ce que le C ne vous donne pas - il n'y a pas de == pour les structures. if (a == b) ne compilera pas. Comparer signifie comparer les membres :

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

Ne prenez pas memcmp comme raccourci. Les compilateurs insèrent des octets de remplissage invisibles entre les membres pour l'alignement, et ces octets peuvent contenir du garbage, donc deux structures aux membres identiques peuvent se comparer différentes octet par octet.

Les tableaux de structures

Parce qu'une structure est un type comme un autre, vous pouvez en faire un tableau - la façon standard de contenir une table d'enregistrements.

#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("Moyenne : %.2f\n", total / n);
    return 0;
}

staff[i].salary se lit « élément i, puis son membre salary » - l'indexation s'attache plus fort que le point, aucune parenthèse n'est donc nécessaire.

Les structures sont copiées dans les fonctions

C'est la règle qui piège les gens. Quand vous passez une structure à une fonction, le C la copie. La fonction travaille sur sa propre copie privée :

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void try_to_move(struct Point p) {
    p.x += 100;   // ne change que la copie
}

double distance_from_origin(struct Point p) {
    return p.x * p.x + p.y * p.y;   // distance au carre, pas besoin de math.h
}

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

    try_to_move(p);
    printf("apres try_to_move : (%d, %d)\n", p.x, p.y);
    printf("distance au carre : %.0f\n", distance_from_origin(p));
    return 0;
}

p vaut toujours (3, 4). Lire une structure par valeur, comme le fait distance_from_origin, est parfaitement acceptable et souvent le choix le plus clair pour de petites structures. Mais si la fonction doit changer la structure de l'appelant - ou si la structure est assez grande pour que la copier soit du gaspillage - passez plutôt un pointeur. C'est le sujet de structures et pointeurs.

Renvoyer une structure par valeur fonctionne de la même façon et est parfaitement légal :

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

Les structures imbriquées

Un membre de structure peut lui-même être une structure. Enchaînez les points pour aller à l'intérieur :

#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 pages\n",
           b.title,
           b.published.year, b.published.month, b.published.day,
           b.pages);
    return 0;
}

b.published.year descend d'un niveau à la fois. L'imbrication est la façon de construire de vrais modèles de données en C - et la structure interne est stockée à l'intérieur de l'externe, pas pointée, donc tout le Book est un bloc de mémoire contigu.

Taille, remplissage et ordre des membres

sizeof vous dit la taille d'une structure, et la réponse est souvent plus grande que la somme de ses membres :

#include <stdio.h>

struct Wasteful {
    char  a;    // 1 octet
    int   b;    // 4 octets
    char  c;    // 1 octet
};

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

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

Sur une machine typique, Wasteful fait 12 octets et Tidy en fait 8, alors que les deux contiennent les mêmes trois membres. Le compilateur insère du remplissage pour que chaque membre soit à une adresse qui plaît à son type - un int veut généralement un multiple de 4. Grouper les membres les plus grands avant les plus petits tend à mieux compacter.

Cela compte rarement (un tableau d'un million d'éléments, la disposition d'un paquet réseau) et jamais pour la justesse de votre propre code. Ce que cela explique, c'est pourquoi sizeof vous surprend, et pourquoi memcmp sur des structures est une mauvaise idée.

Questions fréquentes

Comment déclare-t-on une structure en C ?

Écrivez struct suivi d'un nom d'étiquette et d'une liste de membres entre accolades : struct Point { int x; int y; };. Cela déclare un type, pas une variable. Pour créer une variable, vous écrivez ensuite struct Point p; - le mot struct fait partie du nom du type en C, c'est pourquoi la plupart du code l'associe à un typedef.

Quelle est la différence entre . et -> pour les structures ?

Utilisez . quand vous avez la structure elle-même (p.x) et -> quand vous avez un pointeur dessus (ptr->x). La flèche est un raccourci pour (*ptr).x. Voir structures et pointeurs pour les détails.

Les structures sont-elles passées par valeur ou par référence en C ?

Par valeur, toujours. Passer une structure à une fonction copie chaque membre, donc les changements dans la fonction n'affectent pas la variable de l'appelant. Pour modifier l'original - ou pour éviter de copier une grosse structure - passez plutôt un pointeur.

Comment initialiser une structure en C ?

Soit par position, struct Point p = {3, 4};, soit avec des initialiseurs désignés, struct Point p = {.y = 4, .x = 3};. La forme désignée nomme chaque membre, elle survit donc à un réordonnancement ultérieur de la structure et laisse à zéro les membres non nommés.

Concepts liés