Summary  
This chapter covers how to create arrays of user-defined struct types, access each element’s fields via index and dot notation, and use loops for printing their data.  

General domain of usage  
Managing collections of structured data records.

Creating an array from structures is **no different from creating an array with other data types**.


**Accessing the elements** of such an array is similar to that of ordinary arrays **by indexes**.

```
struct Person {
    char name[50];
    int age;
    double height;
};

struct Person people[2];
```


As an example, let's create an array of structures that will store information about a person.

I2luY2x1ZGUgPHN0ZGlvLmg+CiNpbmNsdWRlIDxzdHJpbmcuaD4KCi8vIHN0cnVjdHVyZSBkZWZpbml0aW9uCnN0cnVjdCBQZXJzb24gewogICAgY2hhciBuYW1lWzUwXTsKICAgIGludCBhZ2U7CiAgICBkb3VibGUgaGVpZ2h0Owp9OwoKaW50IG1haW4oKSB7CiAgICAvLyBkZWNsYXJpbmcgYW4gYXJyYXkgb2Ygc3RydWN0dXJlcwogICAgc3RydWN0IFBlcnNvbiBwZW9wbGVbM107CgogICAgc3RyY3B5KHBlb3BsZVswXS5uYW1lLCAiQWxpY2UiKTsKICAgIHBlb3BsZVswXS5hZ2UgPSAyNTsKICAgIHBlb3BsZVswXS5oZWlnaHQgPSAxLjc1OwoKICAgIHN0cmNweShwZW9wbGVbMV0ubmFtZSwgIkJvYiIpOwogICAgcGVvcGxlWzFdLmFnZSA9IDMwOwogICAgcGVvcGxlWzFdLmhlaWdodCA9IDEuODA7CgogICAgc3RyY3B5KHBlb3BsZVsyXS5uYW1lLCAiQ2hhcmxpZSIpOwogICAgcGVvcGxlWzJdLmFnZSA9IDM1OwogICAgcGVvcGxlWzJdLmhlaWdodCA9IDEuNzA7CgogICAgLy8gb3V0cHV0IGluZm9ybWF0aW9uIGFib3V0IHBlb3BsZSBmcm9tIHRoZSBhcnJheQogICAgZm9yIChpbnQgaSA9IDA7IGkgPCAzOyArK2kpIHsKICAgICAgICBwcmludGYoIlBlcnNvbiAlZDpcbiIsIGkgKyAxKTsKICAgICAgICBwcmludGYoIk5hbWU6ICVzXG4iLCBwZW9wbGVbaV0ubmFtZSk7CiAgICAgICAgcHJpbnRmKCJBZ2U6ICVkXG4iLCBwZW9wbGVbaV0uYWdlKTsKICAgICAgICBwcmludGYoIkhlaWdodDogJS4yZlxuIiwgcGVvcGxlW2ldLmhlaWdodCk7CiAgICAgICAgcHJpbnRmKCJcbiIpOwogICAgfQoKICAgIHJldHVybiAwOwp9

Each element of the `people` array represents a separate `Person` structure. We can access the fields of a specific person using the array index, for example: `people[0].name` or `people[1].age`.

We then loop through the entire array using a `for` loop and print the information of each person to the screen.

Using arrays of structures allows you to store multiple objects of the same type in one place and easily access them by index, which is especially useful when working with large sets of data.

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>

struct Product {
    char name[20];
    int quantity;
    float price;
};

float calculateWarehouseTotal(struct Product items[], int n);

/* ===================== TESTS ===================== */

TEST_CASE("Calculate total for basic warehouse items") {
    Product items[3] = {
        {"Apples", 50, 1.50f},
        {"Bananas", 30, 1.20f},
        {"Oranges", 40, 2.00f}
    };
    REQUIRE(calculateWarehouseTotal(items, 3) == Approx(191.0f));
}

TEST_CASE("Calculate total when all quantities are zero") {
    Product items[3] = {
        {"ItemA", 0, 1.50f},
        {"ItemB", 0, 2.50f},
        {"ItemC", 0, 5.00f}
    };
    REQUIRE(calculateWarehouseTotal(items, 3) == Approx(0.0f));
}

TEST_CASE("Calculate total when all prices are zero") {
    Product items[3] = {
        {"ItemA", 10, 0.0f},
        {"ItemB", 20, 0.0f},
        {"ItemC", 30, 0.0f}
    };
    REQUIRE(calculateWarehouseTotal(items, 3) == Approx(0.0f));
}

TEST_CASE("Calculate total with floating point prices") {
    Product items[3] = {
        {"ItemA", 10, 1.99f},
        {"ItemB", 5,  3.49f},
        {"ItemC", 1,  9.99f}
    };
    REQUIRE(calculateWarehouseTotal(items, 3) == Approx(10*1.99f + 5*3.49f + 9.99f));
}

TEST_CASE("Calculate total with very large quantities") {
    Product items[2] = {
        {"Bulk1", 1000000, 1.00f},
        {"Bulk2", 2000000, 0.50f}
    };
    REQUIRE(calculateWarehouseTotal(items, 2) == Approx(1000000*1.0f + 2000000*0.5f));
}

TEST_CASE("Single product only") {
    Product items[1] = {
        {"Single", 7, 3.75f}
    };
    REQUIRE(calculateWarehouseTotal(items, 1) == Approx(26.25f));
}

test.cpp

Gain a solid understanding of how structs work in C, from basic definitions to advanced memory concepts. Explore how pointers interact with structured data, discover efficient ways to organize information, and build confidence by implementing real data structures such as linked lists.

Explore the fundamentals of structs, understand why they are used, and build confidence in defining, creating, and accessing structured data.

Discover how pointers interact with structs, learn why this connection matters, and master key techniques such as dynamic allocation and passing structs to functions

Gain a solid understanding of how structs are stored in memory, explore alignment and padding, and learn how unions help manage shared data efficiently.

Dive into advanced struct patterns, including nested and anonymous structs, explore practical ways to combine them with arrays, and get familiar with common data structures.

Build confidence by implementing a linked list from scratch, explore its structure, and create essential functions for adding, traversing, and managing list elements.

Arrays with Structs

解答