Antwoord.

Arrays van structuren zijn een van de populaire manieren om uniforme gegevens op te slaan en te verwerken in de taal C, zoals een gegevens tabel, een array van punten, medewerkers, enz.

Achtergrond:

Ondersteuning voor arrays en structuren kwam in de eerste versies van C voor het gemak van gegevensorganisatie. Het werken met arrays van structuren vereist echter inzicht in de kenmerken van de taal, geheugengebruik en principes van gegevensoverdracht.

Probleem:

Fouten ontstaan bij een onjuiste initialisatie van de array van structuren, verwarring met geheugen, het doorgeven van de array aan een functie (kan als een pointer worden doorgegeven), evenals bij toegang tot de velden van structuren via onjuiste indexering.

Oplossing:

Het declareren van een array van structuren gebeurt op dezelfde manier als arrays van basistypen, alleen op basis van een vooraf gedefinieerd structuurtype.
Initialisatie van de array — is mogelijk als volledig, gedeeltelijk en elementgewijs, maar moet strikt in de syntaxis worden gevolgd.
Gebruik en doorgeven — standaard wordt de array doorgegeven aan functies als een pointer, toegang tot de velden via . en ->.

Codevoorbeeld:

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

Belangrijke kenmerken:

Bij het declareren moet het type structuur vooraf worden gedefinieerd.
Bij het doorgeven van een array van structuren aan een functie, wordt een pointer naar het eerste element doorgegeven.
Het is mogelijk te initialiseren met een lijst evenals elementgewijs, met aandacht voor correcte invulling.

Vragen met een valstrik.

Wat is het verschil in toegang tot de velden van een structuur in een array via punt en pijl?

arr[i].field wordt gebruikt als arr[i] de structuur zelf is. ptr->field wordt gebruikt als ptr een pointer naar de structuur is.

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

Bij gedeeltelijke initialisatie van een array van structuren — welke waarden hebben de overige velden?

Bij gedeeltelijke initiatie worden de niet opgegeven velden gevuld met nullen in statisch toegewezen arrays, maar niet voor automatische (stack) variabelen zonder initialisatie.

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

Worden er kopieën van structuren doorgegeven bij het doorgeven van een array van structuren aan een functie?

Nee, er wordt een pointer naar het eerste element van de array doorgegeven, waarbij de functie elementen kan wijzigen omdat het werkt met het originele geheugen.

Typische fouten en anti-patronen

Het gebruik van niet-geïnitialiseerde velden van de structuur.
Verkeerde indexering (bijvoorbeeld points.x in plaats van points[i].x).
Poging om een lokale array van structuren uit een functie te retourneren.

Voorbeeld uit het leven

Negatief geval

De programmeur declareert een array van structuren zonder de velden te initialiseren en geeft deze door aan een functie voor invulling. Gebruikt de . operator in plaats van -> bij het werken met de pointer. Dit resulteerde in typefouten en het gebruik van junkwaarden.

Voordelen:

Kreeg code die compileerbaar is, maakte kennis met fouten van de compiler.

Nadelen:

Tijdens runtime kwamen onverwachte bugs voor, moeilijk op te sporen.

Positief geval

Er werd een expliciete nulinitialisator {0} voor de hele array gebruikt, de functie accepteerde een pointer en grootte, toegang tot de velden werd strikt en overeenkomstig het type ingevoerd (arr[i].x).