Исполняемые доки C: структуры

Q: Как объявить структуру в C?

Напишите struct, затем имя тега и список полей в фигурных скобках: struct Point { int x; int y; };. Это объявляет тип, а не переменную. Чтобы завести переменную, пишут struct Point p; — слово struct в C является частью имени типа, поэтому в большинстве кода его сочетают с typedef.

Q: Чем отличаются `.` и `->` для структур?

Точка используется, когда у вас есть сама структура (p.x), а стрелка — когда у вас указатель на неё (ptr->x). Стрелка — сокращение для (*ptr).x. Подробности — в статье структуры и указатели.

Q: Как инициализировать структуру в C?

Либо по позиции — struct Point p = {3, 4};, либо именованными инициализаторами — struct Point p = {.y = 4, .x = 3};. Именованная форма называет каждое поле, поэтому переживает последующую перестановку полей в структуре, а неупомянутые поля обнуляются.

Массив хранит много значений одного типа. struct делает противоположное: он хранит несколько значений разных типов и обращается с ними как с одной вещью. Точка — это x и y. Сотрудник — это имя, идентификатор и зарплата. Без структур вы носили бы всё это как три отдельные переменные и надеялись, что никогда не перепутаете, чья зарплата чья.

Объявление типа структуры

Объявление структуры называет тег и перечисляет поля в фигурных скобках:

struct Point {
    int x;
    int y;
};

Точка с запятой после закрывающей скобки обязательна, и её пропуск порождает одно из самых сбивающих с толку сообщений об ошибке, которые встретит новичок в C, потому что компилятор винит следующую строку.

Это объявляет тип, а не переменную. В C полное имя типа — struct Point, вместе с ключевым словом:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p;
    p.x = 3;
    p.y = 4;

    printf("(%d, %d)\n", p.x, p.y);
    return 0;
}

Поля читаются и пишутся через оператор точка: p.x. Переменная-структура — обычная переменная: она живёт на стеке, её можно присвоить другой структуре того же типа через =, и она исчезает в конце своей области видимости.

Писать struct Point повсюду утомительно, поэтому почти весь реальный код на C оборачивает объявление в typedef, чтобы тип назывался просто Point.

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

Структуру можно заполнить прямо в момент объявления. Позиционная форма перечисляет значения в порядке объявления полей:

struct Point p = {3, 4};   // x = 3, y = 4

Именованный инициализатор вместо этого называет каждое поле, что яснее и безопаснее:

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee a = {101, "Ada", 92000.0};
    struct Employee b = {.name = "Grace", .id = 102, .salary = 105000.0};
    struct Employee blank = {0};

    printf("%d %s %.2f\n", a.id, a.name, a.salary);
    printf("%d %s %.2f\n", b.id, b.name, b.salary);
    printf("%d [%s] %.2f\n", blank.id, blank.name, blank.salary);
    return 0;
}

Три момента, на которые стоит обратить внимание:

Именованная форма может перечислять поля в любом порядке, поэтому добавление или перестановка поля позже не сдвинет значения в чужие ячейки.
Любое пропущенное поле обнуляется; {0} — идиоматический способ обнулить всю структуру целиком.
Поле char name[32] — это настоящий массив внутри структуры, поэтому строка хранится в самой структуре, а не где-то ещё. Отсюда же следует, что a.name = "Ada"; задним числом недопустимо: нужен strcpy (см. функции для строк).

Структура без инициализатора не инициализирована, и чтение её полей до записи — неопределённое поведение. = {0} не стоит ничего и снимает весь этот класс багов.

Присваивание и сравнение

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

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point a = {1, 2};
    struct Point b = a;   // полная копия

    b.x = 99;

    printf("a = (%d, %d)\n", a.x, a.y);
    printf("b = (%d, %d)\n", b.x, b.y);
    return 0;
}

a осталась нетронутой: b получила собственную копию. Но обратите внимание, чего C не даёт: для структур нет ==. if (a == b) не скомпилируется. Сравнение означает сравнение полей:

if (a.x == b.x && a.y == b.y) { /* равны */ }

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

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

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

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee staff[3] = {
        {101, "Ada",    92000.0},
        {102, "Grace",  105000.0},
        {103, "Alan",   87000.0},
    };

    int n = sizeof(staff) / sizeof(staff[0]);
    double total = 0.0;

    for (int i = 0; i < n; i++) {
        printf("%-3d %-8s %10.2f\n", staff[i].id, staff[i].name, staff[i].salary);
        total += staff[i].salary;
    }

    printf("Среднее: %.2f\n", total / n);
    return 0;
}

staff[i].salary читается как «элемент i, а затем его поле salary»: индексация связывает сильнее точки, поэтому скобки не нужны.

Структуры копируются при передаче в функции

Это то правило, на котором спотыкаются. Когда вы передаёте структуру в функцию, C её копирует. Функция работает со своей собственной копией:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void try_to_move(struct Point p) {
    p.x += 100;   // меняет только копию
}

double distance_from_origin(struct Point p) {
    return p.x * p.x + p.y * p.y;   // квадрат расстояния, math.h не нужен
}

int main(void) {
    struct Point p = {3, 4};

    try_to_move(p);
    printf("после try_to_move: (%d, %d)\n", p.x, p.y);
    printf("квадрат расстояния: %.0f\n", distance_from_origin(p));
    return 0;
}

p по-прежнему (3, 4). Читать структуру по значению, как это делает distance_from_origin, совершенно нормально и для небольших структур часто самый понятный вариант. Но если функция должна изменить структуру вызывающего — или если структура настолько велика, что копировать её расточительно, — передавайте указатель. Этому посвящена статья структуры и указатели.

Возврат структуры по значению работает так же и совершенно законен:

struct Point make_point(int x, int y) {
    struct Point p = {x, y};
    return p;
}

Вложенные структуры

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

#include <stdio.h>

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

struct Book {
    char title[64];
    struct Date published;
    int pages;
};

int main(void) {
    struct Book b = {
        .title = "The C Programming Language",
        .published = {.year = 1978, .month = 2, .day = 22},
        .pages = 228,
    };

    printf("%s (%d-%02d-%02d), страниц: %d\n",
           b.title,
           b.published.year, b.published.month, b.published.day,
           b.pages);
    return 0;
}

b.published.year заходит внутрь по одному уровню за раз. Вложенность — то, как в C строят настоящие модели данных, причём внутренняя структура хранится внутри внешней, а не по указателю, поэтому вся Book — один непрерывный блок памяти.

Размер, выравнивание и порядок полей

sizeof сообщает размер структуры, и ответ часто больше суммы размеров её полей:

#include <stdio.h>

struct Wasteful {
    char  a;    // 1 байт
    int   b;    // 4 байта
    char  c;    // 1 байт
};

struct Tidy {
    int   b;
    char  a;
    char  c;
};

int main(void) {
    printf("Wasteful: %zu байт\n", sizeof(struct Wasteful));
    printf("Tidy:     %zu байт\n", sizeof(struct Tidy));
    return 0;
}

На типичной машине Wasteful занимает 12 байт, а Tidy — 8, хотя обе хранят одни и те же три поля. Компилятор вставляет выравнивающие байты, чтобы каждое поле оказалось по адресу, который нравится его типу: int обычно хочет адрес, кратный 4. Группировка более крупных полей перед мелкими обычно упаковывается плотнее.

Это редко имеет значение (массив на миллион элементов, раскладка сетевого пакета) и никогда не влияет на корректность вашего собственного кода. Зато объясняет, почему sizeof вас удивляет и почему memcmp на структурах — плохая идея.

Часто задаваемые вопросы

Как объявить структуру в C?

Напишите struct, затем имя тега и список полей в фигурных скобках: struct Point { int x; int y; };. Это объявляет тип, а не переменную. Чтобы завести переменную, пишут struct Point p; — слово struct в C является частью имени типа, поэтому в большинстве кода его сочетают с typedef.

Чем отличаются . и -> для структур?

Точка используется, когда у вас есть сама структура (p.x), а стрелка — когда у вас указатель на неё (ptr->x). Стрелка — сокращение для (*ptr).x. Подробности — в статье структуры и указатели.

Структуры в C передаются по значению или по ссылке?

Всегда по значению. Передача структуры в функцию копирует каждое поле, поэтому изменения внутри функции не затрагивают переменную вызывающего. Чтобы изменить оригинал — или чтобы не копировать большую структуру, — передавайте указатель.

Как инициализировать структуру в C?

Либо по позиции — struct Point p = {3, 4};, либо именованными инициализаторами — struct Point p = {.y = 4, .x = 3};. Именованная форма называет каждое поле, поэтому переживает последующую перестановку полей в структуре, а неупомянутые поля обнуляются.

Связанные концепции

Структуры в C: объявление, инициализация и использование struct