Réponse.

Les tableaux de structures sont l'un des moyens populaires de stockage et de traitement de données homogènes en langage C, comme les tableaux de données, les tableaux de points, d'employés, etc.

Contexte de la question :

Le support des tableaux et des structures est apparu dans les premières versions de C pour faciliter l'organisation des données. Cependant, le travail avec des tableaux de structures nécessite de comprendre les particularités du langage, la gestion de la mémoire et les principes de transmission des données.

Problème :

Des erreurs surviennent lors d'une mauvaise initialisation du tableau de structures, une confusion avec la mémoire, le passage du tableau à une fonction (il peut être passé comme un pointeur), ainsi que lors d'erreurs d'accès aux champs des structures par un index incorrect.

Solution :

La déclaration d'un tableau de structures se fait de la même manière que celle des tableaux de types de base, mais sur la base d'un type de structure préalablement déclaré.
L'initialisation du tableau est possible de manière complète, partielle et élément par élément, mais il faut suivre strictement la syntaxe.
L'utilisation et le passage — par défaut, le tableau est passé à la fonction comme un pointeur, l'accès aux champs se fait via . et ->.

Exemple de code :

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void print_points(struct Point *arr, int size) {
    for(int i = 0; i < size; ++i) {
        printf("(%d, %d)
", arr[i].x, arr[i].y);
    }
}

int main() {
    struct Point points[3] = { {1,2}, {3,4}, {5,6} };
    print_points(points, 3);
    return 0;
}

Caractéristiques clés :

Lors de la déclaration, il est nécessaire de définir au préalable le type de structure.
En passant un tableau de structures à une fonction, un pointeur vers le premier élément est passé.
Il est possible d'initialiser à la fois par liste et élément par élément, en veillant à un remplissage correct.

Questions pièges.

Quelle est la différence d'accès aux champs d'une structure dans un tableau via le point et la flèche ?

arr[i].field est utilisé si arr[i] est la structure elle-même. ptr->field est utilisé si ptr est un pointeur vers une structure.

struct Point *p = &points[0];
printf("%d", p->x); // correct
// points[0].x — c'est aussi correct

Lors d'une initialisation partielle d'un tableau de structures, quelles valeurs auront les autres champs ?

Lors d'une initialisation partielle, les champs non spécifiés sont remplis avec des zéros dans les tableaux de manière statiquement allouée, mais pas pour les variables automatiques (de pile) non initialisées.

struct Point arr[2] = { {10} }; // arr[0].x = 10, arr[0].y = 0, arr[1].x et arr[1].y = 0

Les structures sont-elles copiées lors du passage d'un tableau de structures à une fonction ?

Non, un pointeur vers le premier élément du tableau est passé, la fonction peut modifier l'élément(s) car elle travaille avec la mémoire originale.

Erreurs typiques et anti-patterns

Utilisation de champs de structure non initialisés.
Indexation confondue (par exemple points.x au lieu de points[i].x).
Tentative de retourner un tableau de structures local d'une fonction.

Exemple de la vie réelle

Cas négatif

Un programmeur a déclaré un tableau de structures sans initialiser les champs et l'a passé à une fonction pour le remplir. Il a utilisé l'opérateur . au lieu de -> lorsqu'il travaillait avec un pointeur. En conséquence, une erreur de type et l'utilisation de valeurs indésirables se sont produites.

Avantages :

Code compilable, il a pris connaissance des erreurs du compilateur.

Inconvénients :

À l'exécution, des bugs inattendus sont apparus, difficiles à traquer.

Cas positif

Un initialiseur nul explicite {0} a été utilisé pour l'ensemble du tableau, la fonction recevait un pointeur et une taille, l'accès aux champs a été introduit de manière stricte et conformément au type (arr[i].x).