Answer.

Arrays of structures are one of the popular ways to store and process homogeneous data in C, like tables of data, arrays of points, employees, etc.

Background:

Support for arrays and structures appeared in the early versions of C for the convenience of organizing data. However, working with arrays of structures requires an understanding of the language's nuances, memory management, and data passing principles.

Problem:

Errors occur due to incorrect initialization of an array of structures, confusion with memory, passing an array to a function (it may be passed as a pointer), as well as access errors to structure fields through incorrect indexing.

Solution:

Declaration of an array of structures is done similarly to arrays of basic types, based on a previously declared structure type.
Initialization of the array is possible in full, partial, and element-wise forms, but it is necessary to strictly follow the syntax.
Usage and passing: an array is by default passed to functions as a pointer, access to fields is done through . and ->.

Example 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)\n", arr[i].x, arr[i].y);
    }
}

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

Key features:

When declaring, it is necessary to define the structure type beforehand.
When passing an array of structures to a function, a pointer to the first element is passed.
It is possible to initialize it both as a list and element-wise, ensuring correct filling.

Trick questions.

What is the difference between accessing structure fields in an array using dot and arrow notation?

arr[i].field is used when arr[i] is the structure itself. ptr->field is used when ptr is a pointer to the structure.

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

If partially initializing an array of structures, what values will the other fields have?

When partially initialized, unspecified fields are filled with zeros in statically allocated arrays, but not for automatic (stack) variables without initialization.

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

Are copies of structures made when passing an array of structures to a function?

No, a pointer to the first element of the array is passed, and the function can modify the element(s) since it operates on the original memory.

Common mistakes and anti-patterns

Using uninitialized structure fields.
Confused indexing (for example points.x instead of points[i].x).
Attempting to return a local array of structures from a function.

Real-life examples

Negative case

A programmer declared an array of structures without initializing the fields and passed it to a function for filling. They used the dot operator instead of the arrow operator when working with a pointer. As a result, a type error occurred and garbage values were used.

Pros:

Received compilable code, became acquainted with compiler errors.

Cons:

Unexpected runtime bugs occurred that were hard to catch.

Positive case

An explicit zero initializer {0} was used for the whole array, the function accepted a pointer and size, and access to the fields was strictly adhered to per type (arr[i].x).