6.1. Структурные типы и структуры

Теория

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

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

Например, товар на складе может иметь название, цену, процент наценки, количество единиц и дату поставки. Студент может иметь имя, фамилию, курс и номер группы. Комплексное число может состоять из действительной и мнимой частей. Для таких задач в языке Си используются структуры.

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

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

Производные типы данных

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

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

Важно не путать строку с отдельным типом данных. В Си нет самостоятельного строкового типа в том смысле, как он есть во многих других языках. Строка в Си — это частный случай массива символов типа char, который заканчивается нулевым символом '\0'.

char text[] = "Hello";

Здесь text — это массив символов, а не объект специального строкового типа.

Скалярные, агрегирующие и неагрегирующие типы

Данные базовых типов, например int, float, double, обычно называют скалярными. Такой объект хранит одно значение.

int age;
double price;

Массивы и структуры относятся к агрегирующим типам данных. Агрегирующий объект объединяет несколько компонентов.

long b[12];

Массив b состоит из 12 элементов типа long. Все эти элементы размещаются в памяти как части одного объекта-массива.

Для массива удобно вычислять количество элементов через sizeof:

sizeof(b) / sizeof(b[0])

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

Структура тоже является агрегирующим типом, но в отличие от массива она может состоять из элементов разных типов.

Что такое структура

Структура — это объединённое в единое целое множество поименованных элементов данных. Эти элементы также называют компонентами или полями структуры.

Главное отличие структуры от массива:

Массив Структура
Все элементы одного типа Элементы могут быть разных типов
Доступ по индексу: a[0], a[1] Доступ по имени поля: coat.price
Элементы обычно однотипны по смыслу Поля описывают разные свойства одного объекта

Например, товар на складе можно представить набором полей:

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

Определение структурного типа

Чтобы создавать структуры, сначала обычно определяют структурный тип. Для этого используется служебное слово struct.

struct goods {
    char *name;      /* Наименование */
    long price;      /* Цена оптовая */
    float percent;   /* Наценка в процентах */
    int vol;         /* Объем партии */
    char date[11];   /* Дата поставки */
};

Здесь:

Общий формат определения структурного типа:

struct имя_структурного_типа
{
    определения_элементов
};

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

Структурный тип — это ещё не объект

Определение структурного типа похоже на чертёж или шаблон. Оно говорит компилятору: «объекты такого типа будут состоять из таких-то полей».

Но сами поля пока не получают значений, потому что конкретной структуры ещё нет.

struct goods {
    char *name;
    long price;
    float percent;
    int vol;
    char date[11];
};

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

Также в определении структурного типа нельзя инициализировать поля:

/* Неверно */
struct goods {
    char *name = "tea";
    long price = 100;
};

Значения получают не поля типа, а поля конкретной структуры-объекта.

Определение объектов структурного типа

Когда структурный тип уже определён, можно создавать конкретные структуры этого типа.

struct goods coat, tea;

Здесь создаются два объекта структурного типа struct goods: coat и tea. Для каждого из них выделяется память, достаточная для хранения всех полей структуры.

Общий формат:

struct имя_структурного_типа список_структур;

Например:

struct goods coat;
struct goods tea;
struct goods sugar, coffee;

Каждая из этих структур имеет одинаковый набор полей: name, price, percent, vol, date. Но значения этих полей у разных объектов могут быть разными.

Одновременное определение типа и объектов

Структурный тип и объекты этого типа можно определить одной конструкцией.

struct student
{
    char name[15];
    char surname[20];
    int year;
} student_1, student_2, student_3;

Здесь одновременно:

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

struct student leader, freshman;

Такая запись удобна, когда тип будет использоваться в программе несколько раз.

Безымянный структурный тип

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

struct
{
    char processor[10];
    int frequency;
    int memory;
    int disk;
} acer, hp, compaq;

Здесь созданы три структуры: acer, hp, compaq. Каждая из них содержит сведения о компьютере:

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

struct computer another_pc;

Такого имени типа просто нет. Если нужно создавать объекты такого вида в разных местах программы, лучше дать структурному типу имя.

Использование typedef со структурами

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

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

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

complex z1, z2;

Без typedef пришлось бы писать более длинную форму с struct.

Структурный тип может иметь и обычное имя после struct, и сокращённое имя через typedef.

typedef struct rational_fraction
{
    int numerator;
    int denominator;
} fraction;

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

struct rational_fraction a;
fraction b;

Оба объекта будут иметь поля numerator и denominator.

Память для структур

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

struct goods coat;

Для coat нужно разместить:

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

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

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

sizeof(struct goods)
sizeof(coat)

Если уже создан объект coat, можно написать:

printf("%lu\n", (unsigned long)sizeof(coat));

Конкретный результат зависит от компилятора, платформы и правил выравнивания.

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

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

struct goods coat = {
    "пиджак черный",
    3600,
    7.5,
    220,
    "12.01.2011"
};

Значения присваиваются полям по порядку:

Для структуры, определённой через typedef, инициализация выглядит так же:

complex sigma = {1.3, 12.6};

Здесь sigma.real равно 1.3, а sigma.imag равно 12.6.

Присваивание структур

Структуры можно присваивать друг другу, если они имеют один и тот же структурный тип.

struct goods coat = {
    "пиджак черный",
    3600,
    7.5,
    220,
    "12.01.2011"
};

struct goods tea;

tea = coat;

После присваивания значения полей структуры coat копируются в соответствующие поля структуры tea.

Это важное отличие от массивов. Массивы напрямую присваивать нельзя:

float x[5] = {1.0, 2.0, 3.0, 4.0, 5.0};
float z[5];

/* Ошибка */
z = x;

Массив копируют поэлементно:

int j;

for (j = 0; j < sizeof(x) / sizeof(x[0]); j++)
    z[j] = x[j];

А вот для структур одного типа обычное присваивание разрешено:

complex sport;
complex sigma = {1.3, 12.6};

sport = sigma;

Сравнение структур

Хотя структуры можно присваивать, для них не определены операции сравнения целиком. Нельзя просто написать:

if (tea == coat)
{
    printf("Структуры равны\n");
}

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

if (tea.price == coat.price &&
    tea.percent == coat.percent &&
    tea.vol == coat.vol)
{
    printf("Числовые поля совпадают\n");
}

Для строковых полей сравнение усложняется: строки нельзя надёжно сравнивать через ==, потому что это сравнит адреса, а не содержимое строк. Для сравнения строк используется функция strcmp из заголовочного файла string.h.

Доступ к элементам структуры

Чтобы обратиться к полю структуры, используется операция «точка»:

имя_структуры.имя_элемента

Например:

coat.price
coat.percent
coat.vol
coat.date

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

/* Неверно */
struct goods.price;

/* Верно */
coat.price;

Выражение с точкой называют уточнённым именем. Оно ведёт себя как обычное имя объекта соответствующего типа. Например, если coat.price имеет тип long, его можно выводить через %ld, использовать в выражениях и присваиваниях.

coat.price = 4000;
coat.vol = coat.vol + 10;

Программа: вывод информации о товаре

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

#include <stdio.h>

int main(void)
{
    struct goods {
        char *name;
        long price;
        float percent;
        int vol;
        char date[11];
    };

    struct goods coat = {
        "пиджак черный",
        3600,
        7.5,
        220,
        "12.01.2011"
    };

    printf("\nТовар на складе:");
    printf("\nНаименование: %s.", coat.name);
    printf("\nОптовая цена: %ld руб.", coat.price);
    printf("\nНаценка: %4.1f %%.", coat.percent);
    printf("\nОбъем партии: %d штук.", coat.vol);
    printf("\nДата поставки: %s.", coat.date);

    return 0;
}

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

Товар на складе:
Наименование: пиджак черный.
Оптовая цена: 3600 руб.
Наценка: 7.5 %.
Объем партии: 220 штук.
Дата поставки: 12.01.2011.

Обратите внимание на строку:

printf("\nНаценка: %4.1f %%.", coat.percent);

Чтобы вывести символ процента в printf, его нужно записать как %%. Один символ % воспринимается как начало спецификации формата.

Изменение полей структуры

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

coat.price = 3900;
coat.percent = 10.0;
coat.vol = 180;

Если нужно ввести новое значение поля с клавиатуры, в scanf передаётся адрес этого поля:

printf("\nВведите торговую наценку: ");
scanf("%f", &coat.percent);

Здесь &coat.percent — адрес поля percent внутри структуры coat.

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

printf("Цена товара: %ld руб.",
       (long)(coat.price * (1.0 + coat.percent / 100.0)));

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

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

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

#include <stdio.h>

int main(void)
{
    struct student {
        char name[20];
        char surname[30];
        int year;
        float average_mark;
    };

    struct student st = {
        "Ivan",
        "Petrov",
        2,
        4.35
    };

    printf("Студент: %s %s\n", st.name, st.surname);
    printf("Курс: %d\n", st.year);
    printf("Средний балл: %.2f\n", st.average_mark);

    st.year = st.year + 1;

    printf("После перевода на следующий курс: %d\n", st.year);

    return 0;
}

Что происходит в программе:

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

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

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

struct goods {
    char *name;
    long price;
}

После закрывающей фигурной скобки нужна точка с запятой:

struct goods {
    char *name;
    long price;
};

Ошибка 2. Считать определение типа созданием объекта

struct goods {
    char *name;
    long price;
};

/* Здесь еще нет объекта goods */

Чтобы появился объект, нужно написать:

struct goods coat;

Ошибка 3. Пытаться инициализировать поля внутри определения типа

/* Неверно */
struct point {
    int x = 0;
    int y = 0;
};

Правильно инициализировать конкретный объект:

struct point {
    int x;
    int y;
};

struct point p = {0, 0};

Ошибка 4. Писать имя типа перед точкой

/* Неверно */
struct goods.price = 100;

Перед точкой должно стоять имя конкретной структуры:

coat.price = 100;

Ошибка 5. Пытаться сравнивать структуры через ==

/* Неверно */
if (a == b)
{
    printf("equal\n");
}

Структуры сравнивают поэлементно:

if (a.x == b.x && a.y == b.y)
{
    printf("equal\n");
}

Ошибка 6. Путать присваивание структур и массивов

struct point p1 = {1, 2};
struct point p2;

p2 = p1; /* Верно для структур */
int a[3] = {1, 2, 3};
int b[3];

b = a; /* Неверно для массивов */

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

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

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

  1. Какие типы данных называются производными?
  2. Почему строка в Си не считается отдельным строковым типом?
  3. Чем агрегирующий тип отличается от скалярного?
  4. Чем структура отличается от массива?
  5. Что задаёт определение структурного типа?
  6. Почему после определения структуры нужна точка с запятой?
  7. Выделяется ли память при определении только структурного типа?
  8. Как создать объект типа struct goods?
  9. Для чего используется typedef?
  10. Как обратиться к полю price структуры coat?
  11. Можно ли присвоить одну структуру другой?
  12. Можно ли сравнить две структуры через ==?
  13. Почему размер структуры лучше узнавать через sizeof?
  14. Что означает запись &coat.percent?