6.2. Структуры, массивы и указатели

Теория

Зачем нужен этот пункт

В предыдущем пункте мы познакомились со структурами как с объектами, которые объединяют несколько полей разных типов. Теперь нужно разобраться, как структуры взаимодействуют с другими важными средствами языка Си: массивами и указателями.

В реальных программах структуры почти никогда не используются изолированно. Часто нужно хранить массив товаров, массив студентов, массив точек, массив комплексных чисел. Также часто нужно передавать структуру через указатель, изменять её поля по адресу или связывать несколько структур друг с другом.

После изучения этого пункта нужно понимать:

Массив как элемент структуры

Полем структуры может быть не только отдельная переменная, но и массив. Например, если структура описывает материальную точку в пространстве, ей нужны масса и три координаты.

struct particle {
    double mass;
    float coord[3];
};

Здесь поле mass хранит массу точки, а поле coord — массив из трёх координат: coord[0], coord[1], coord[2].

Если создан объект:

struct particle point;

то обращаться к координатам нужно так:

point.coord[0]
point.coord[1]
point.coord[2]

Обратите внимание на порядок записи: сначала имя структуры, затем точка, затем имя массива-поля, затем индекс. Индекс относится именно к массиву coord, а не ко всей структуре.

Пример: длина радиус-вектора точки

Пусть структура хранит массу точки и её координаты. Вычислим расстояние от начала координат до этой точки. Для точки с координатами x, y, z длина радиус-вектора равна:

sqrt(x * x + y * y + z * z)

В программе координаты хранятся в массиве coord, поэтому сумму квадратов удобно вычислить в цикле.

#include <stdio.h>
#include <math.h>

int main(void)
{
    struct {
        double mass;
        float coord[3];
    } point = {12.3, {1.0, 2.0, -3.0}};

    int i;
    double s = 0.0;

    for (i = 0; i < 3; i++)
        s += point.coord[i] * point.coord[i];

    printf("Длина радиус-вектора: %f\n", sqrt(s));

    return 0;
}

Результат:

Длина радиус-вектора: 3.741657

В этом примере структурный тип безымянный. Мы не вводим имя типа через struct particle, а сразу создаём объект point. Такой приём допустим, когда тип нужен только для одного конкретного объекта.

В инициализации используется вложенный список:

{12.3, {1.0, 2.0, -3.0}}

Внешние фигурные скобки относятся ко всей структуре, а внутренние — к массиву coord.

Структура как элемент другой структуры

Полем структуры может быть другая структура. Это называется вложением структур. Например, можно отдельно описать дату, а затем использовать её в структуре товара.

struct date {
    int day;
    int month;
    int year;
};

struct goods {
    char name[30];
    long price;
    struct date delivery_date;
};

Здесь поле delivery_date само является структурой типа struct date. Если создать товар:

struct goods coat = {
    "coat",
    3600,
    {12, 1, 2011}
};

то к полям вложенной структуры можно обратиться цепочкой операций «точка»:

coat.delivery_date.day
coat.delivery_date.month
coat.delivery_date.year

Такая запись читается слева направо: взять структуру coat, внутри неё взять поле delivery_date, а внутри этого поля взять day, month или year.

Пример: вложенная структура даты

#include <stdio.h>

int main(void)
{
    struct date {
        int day;
        int month;
        int year;
    };

    struct goods {
        char name[30];
        long price;
        struct date delivery_date;
    };

    struct goods item = {
        "black coat",
        3600,
        {12, 1, 2011}
    };

    printf("Товар: %s\n", item.name);
    printf("Цена: %ld\n", item.price);
    printf("Дата поставки: %02d.%02d.%04d\n",
           item.delivery_date.day,
           item.delivery_date.month,
           item.delivery_date.year);

    return 0;
}

Возможный результат:

Товар: black coat
Цена: 3600
Дата поставки: 12.01.2011

Вложенные структуры удобны, когда один логический объект естественно состоит из других логических объектов. Дата, адрес, точка, координаты, паспортные данные, характеристики товара — всё это часто оформляют отдельными структурами.

Массив структур

Если нужно хранить несколько однотипных объектов, создают массив структур. Например, массив товаров:

#define MAX_GOODS 100

struct goods {
    char name[30];
    long price;
    float percent;
    int vol;
};

struct goods list[MAX_GOODS];

Здесь list — массив из MAX_GOODS структур. Каждый элемент массива — отдельная структура типа struct goods.

Доступ к полям элемента массива выполняется так:

list[0].price
list[0].percent
list[8].vol
list[15].name

Сначала индексом выбирается нужная структура из массива, затем через точку выбирается поле этой структуры.

Правильный порядок:

имя_массива[индекс].имя_поля

Ошибочная запись:

list.percent[8]

Такая запись неверна, потому что list — это массив структур, а не структура с полем percent. Индекс должен стоять сразу после имени массива: list[8].percent.

Инициализация массива структур

Массив структур можно инициализировать при определении. Для этого используется список структур, а каждая структура задаётся своим списком значений.

struct particle {
    double mass;
    float coord[3];
};

struct particle points[] = {
    {20.0, {2.0, 4.0, 6.0}},
    {40.0, {6.0, -2.0, 8.0}},
    {10.0, {1.0, 3.0, 2.0}}
};

Здесь создан массив points из трёх структур. Количество элементов массива компилятор определяет по количеству начальных значений.

Элементы массива:

points[0]  /* первая структура */
points[1]  /* вторая структура */
points[2]  /* третья структура */

Поля этих структур:

points[0].mass
points[0].coord[0]
points[1].coord[2]

Пример: вычисление центра масс

Рассмотрим систему материальных точек. Каждая точка имеет массу и три координаты. Центр масс вычисляется по формулам:

общая_масса = сумма всех масс

xc = сумма(mass[i] * x[i]) / общая_масса
yc = сумма(mass[i] * y[i]) / общая_масса
zc = сумма(mass[i] * z[i]) / общая_масса

Для хранения точек используем массив структур. Для результата используем ещё одну структуру того же типа.

#include <stdio.h>

struct particle {
    double mass;
    float coord[3];
};

int main(void)
{
    struct particle mass_point[] = {
        {20.0, {2.0, 4.0, 6.0}},
        {40.0, {6.0, -2.0, 8.0}},
        {10.0, {1.0, 3.0, 2.0}}
    };

    struct particle center = {0.0, {0.0, 0.0, 0.0}};

    int n;
    int i;

    n = sizeof(mass_point) / sizeof(mass_point[0]);

    for (i = 0; i < n; i++)
    {
        center.mass += mass_point[i].mass;

        center.coord[0] += mass_point[i].coord[0] * mass_point[i].mass;
        center.coord[1] += mass_point[i].coord[1] * mass_point[i].mass;
        center.coord[2] += mass_point[i].coord[2] * mass_point[i].mass;
    }

    printf("Координаты центра масс:\n");

    for (i = 0; i < 3; i++)
    {
        center.coord[i] /= center.mass;
        printf("Координата %d: %f\n", i + 1, center.coord[i]);
    }

    return 0;
}

Результат:

Координаты центра масс:
Координата 1: 4.142857
Координата 2: 0.428571
Координата 3: 6.571429

Обратите внимание на выражение:

n = sizeof(mass_point) / sizeof(mass_point[0]);

Оно вычисляет количество элементов массива структур. Общий размер массива делится на размер одного элемента.

Указатели на структуры

Как и для обычных типов, для структур можно создавать указатели. Указатель на структуру хранит адрес структуры.

struct goods *p_goods;
struct particle *p_point;

Если структура уже создана, указатель можно настроить на неё с помощью операции получения адреса:

struct particle point = {12.3, {1.0, 2.0, -3.0}};
struct particle *p = &point;

Теперь p хранит адрес структуры point.

Если структурный тип введён через typedef, то при объявлении указателя служебное слово struct не пишется.

typedef struct {
    double real;
    double imag;
} complex;

complex z;
complex *pz = &z;

Доступ к полям через указатель: (*p).field

Если есть указатель на структуру, сначала нужно получить саму структуру через разыменование, а затем обратиться к её полю через точку.

(*p).mass
(*p).coord[0]

Скобки здесь обязательны. Операция . имеет более высокий приоритет, чем операция разыменования *. Поэтому запись без скобок:

*p.mass

будет понята неправильно: компилятор сначала попытается взять поле mass у объекта p, но p — это указатель, а не структура.

Правильно:

(*p).mass = 33.3;
(*p).coord[1] = 12.3;

Операция стрелка ->

Так как запись (*p).field встречается часто, в языке Си есть специальная операция косвенного выбора компонента:

p->field

Она означает то же самое, что:

(*p).field

Например:

p->mass       /* то же самое, что (*p).mass */
p->coord[0]   /* то же самое, что (*p).coord[0] */

Слева от -> должен быть указатель на структуру, справа — имя поля этой структуры.

#include <stdio.h>

struct particle {
    double mass;
    float coord[3];
};

int main(void)
{
    struct particle point = {12.3, {1.0, 2.0, -3.0}};
    struct particle *p = &point;
    int i;

    p->mass = 18.4;

    for (i = 0; i < 3; i++)
        p->coord[i] = 0.1f * i;

    printf("mass = %f\n", point.mass);
    printf("coord[0] = %f\n", point.coord[0]);
    printf("coord[1] = %f\n", point.coord[1]);
    printf("coord[2] = %f\n", point.coord[2]);

    return 0;
}

Операция -> делает код короче и понятнее, когда работа идёт через указатель на структуру.

Точка и стрелка: когда что использовать

Что есть в программе Как обращаться к полю Пример
Обычная структура Через точку point.mass
Указатель на структуру Через стрелку p->mass
Указатель на структуру, полная форма Разыменование и точка (*p).mass

Практическое правило:

Операции над указателями на структуры

Указатели на структуры подчиняются тем же общим правилам, что и указатели на другие типы данных. Если указатель указывает на элемент массива структур, то операция ++ перемещает его к следующей структуре массива.

struct particle points[3];
struct particle *p;

p = &points[0];

p++; /* теперь p указывает на points[1] */

При увеличении указателя адрес изменяется не на один байт, а на размер одной структуры. Поэтому такой проход по массиву структур работает естественно.

Пример: сумма комплексных чисел через указатель

Пусть комплексное число хранится в структуре с двумя полями: действительная часть x и мнимая часть y. Нужно сложить все комплексные числа из массива структур.

#include <stdio.h>

int main(void)
{
    struct complex {
        float x;
        float y;
    };

    struct complex array[] = {
        {1.0, 2.0},
        {3.0, -4.0},
        {-5.0, -6.0},
        {-7.0, -8.0}
    };

    struct complex summa = {0.0, 0.0};
    struct complex *point = &array[0];

    int k;
    int i;

    k = sizeof(array) / sizeof(array[0]);

    for (i = 0; i < k; i++)
    {
        summa.x += point->x;
        summa.y += point->y;
        point++;
    }

    printf("Сумма: real=%f, imag=%f\n", summa.x, summa.y);

    return 0;
}

Результат:

Сумма: real=-8.000000, imag=-16.000000

В программе:

Структура не может содержать объект своего же типа

В структуру можно включать поля разных типов, в том числе уже определённые структуры. Но структура не может содержать объект точно такого же типа, как она сама.

/* Неверно */
struct node {
    int value;
    struct node next;
};

Такая запись невозможна: чтобы определить размер struct node, компилятору нужно знать размер поля next. Но next снова имеет тип struct node, внутри которого снова есть next, и так бесконечно.

Правильный способ — хранить не сам объект того же типа, а указатель на него:

struct node {
    int value;
    struct node *next;
};

Размер указателя известен, поэтому такая структура допустима. Именно на этом основаны списки, деревья и другие динамические структуры данных.

Указатель на структуру как поле структуры

Полем структуры может быть указатель на структуру того же типа. Например, структура для хранения химического элемента может содержать указатель на следующий элемент:

struct element {
    int number;                 /* Порядковый номер */
    double mass;                /* Атомная масса */
    char name[16];              /* Название элемента */
    struct element *next;       /* Указатель на следующий элемент */
};

Поле next не хранит сам следующий элемент. Оно хранит только его адрес. Благодаря этому можно связать несколько структур в цепочку.

struct element h = {1, 1.008, "Hydrogen", NULL};
struct element he = {2, 4.0026, "Helium", NULL};

h.next = &he;

Теперь из структуры h можно перейти к структуре he:

printf("%s\n", h.next->name);

Здесь h.next — указатель на структуру, поэтому для доступа к полю следующей структуры используется операция ->.

Перекрёстные связи между структурами

Иногда две структуры должны ссылаться друг на друга. Например, преподаватель может иметь указатель на группу, а группа — указатель на куратора.

Для таких случаев используют предварительное объявление структурного типа. Оно сообщает компилятору, что такой структурный тип существует, но его поля будут описаны позже.

struct group; /* Предварительное объявление */

struct teacher {
    char name[30];
    struct group *curator_group;
};

struct group {
    char code[20];
    struct teacher *curator;
};

Здесь структура teacher может содержать указатель на struct group, хотя полное определение struct group появилось ниже. Это допустимо, потому что для объявления указателя компилятору не нужно знать полный размер структуры, достаточно знать, что такой тип существует.

Но если бы поле было не указателем, а самой структурой, такая схема не сработала бы.

Мини-разбор программы

Разберём программу, которая создаёт массив товаров, выводит их цены и находит суммарное количество единиц товара на складе.

#include <stdio.h>

#define COUNT 3

struct goods {
    char name[30];
    long price;
    int vol;
};

int main(void)
{
    struct goods list[COUNT] = {
        {"tea", 150, 20},
        {"coffee", 430, 15},
        {"sugar", 90, 40}
    };

    struct goods *p;
    int i;
    int total = 0;

    p = &list[0];

    for (i = 0; i < COUNT; i++)
    {
        printf("%s: price=%ld, vol=%d\n",
               p->name, p->price, p->vol);

        total += p->vol;
        p++;
    }

    printf("Всего единиц товара: %d\n", total);

    return 0;
}

В программе:

Возможный результат:

tea: price=150, vol=20
coffee: price=430, vol=15
sugar: price=90, vol=40
Всего единиц товара: 75

Типичные ошибки

Ошибка 1. Неверно поставить индекс при обращении к массиву структур

/* Неверно */
list.price[0] = 100;

/* Верно */
list[0].price = 100;

Индекс выбирает элемент массива. Поэтому он должен стоять сразу после имени массива.

Ошибка 2. Забыть скобки в записи через указатель

/* Неверно */
*p.mass = 10.0;

/* Верно */
(*p).mass = 10.0;

/* Еще лучше */
p->mass = 10.0;

Операция . имеет высокий приоритет, поэтому без скобок запись будет разобрана не так, как ожидает программист.

Ошибка 3. Использовать точку вместо стрелки

struct particle *p;

/* Неверно */
p.mass = 10.0;

/* Верно */
p->mass = 10.0;

Точка используется для структуры, стрелка — для указателя на структуру.

Ошибка 4. Использовать стрелку для обычной структуры

struct particle point;

/* Неверно */
point->mass = 10.0;

/* Верно */
point.mass = 10.0;

Ошибка 5. Поместить в структуру объект того же типа

/* Неверно */
struct cell {
    int value;
    struct cell next;
};

Нужно использовать указатель:

struct cell {
    int value;
    struct cell *next;
};

Ошибка 6. Забыть инициализировать указатель

struct particle *p;

/* Опасно: p не указывает на корректную структуру */
p->mass = 10.0;

Перед использованием указатель должен получить корректный адрес:

struct particle point;
struct particle *p = &point;

p->mass = 10.0;

Ошибка 7. Выйти указателем за пределы массива

for (i = 0; i <= n; i++)
{
    printf("%f\n", p->mass);
    p++;
}

Если в массиве n элементов, допустимы индексы от 0 до n - 1. Условие должно быть i < n, а не i <= n.

Практические рекомендации

Что нужно запомнить

Самопроверка перед переходом дальше

  1. Как объявить структуру, в которой одно из полей является массивом из трёх координат?
  2. Как обратиться к элементу coord[2] структуры point?
  3. Как обратиться к полю price первого элемента массива структур list?
  4. Почему запись list.price[0] неверна для массива структур?
  5. Как объявить указатель на структуру struct goods?
  6. Что означает запись struct goods *p = &item;?
  7. Чем отличаются записи item.price и p->price?
  8. Почему в записи (*p).price нужны скобки?
  9. Чему эквивалентна запись p->coord[0]?
  10. Что произойдёт с указателем на структуру после операции p++, если он указывает на элемент массива структур?
  11. Почему структура не может содержать объект своего же типа напрямую?
  12. Почему структура может содержать указатель на структуру того же типа?
  13. Для чего нужны поля вида struct node *next?
  14. Что нужно проверить перед использованием указателя на структуру?