Структуры в C++: объединение связанных данных в один тип

Зачем объединять данные

До сих пор каждая переменная существовала сама по себе: int здесь, string там. Но реальные программы имеют дело с вещами, состоящими из нескольких частей: у точки есть x и y, у студента есть имя, возраст и средний балл. Передавать всё это в виде разрозненных, отдельных переменных чревато ошибками; ничто их не связывает, и функция, которой нужны все три, должна принимать все три параметра.

Структура решает эту проблему. Она определяет новый тип, который объединяет связанные переменные — свои поля — в единое целое. После определения вы работаете со всем набором как с одним значением, которое можно хранить, копировать и передавать в функции.

#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    int age;
    double gpa;
};   // <- не забудьте точку с запятой после закрывающей скобки

int main() {
    Student s;          // один объект, содержащий все три поля
    s.name = "Ada";
    s.age = 19;
    s.gpa = 3.9;

    cout << s.name << " is " << s.age << " (GPA " << s.gpa << ")\n";
}

К каждому полю вы обращаетесь через оператор точки (s.name, s.age). Точка с запятой после закрывающей } определения структуры обязательна — её отсутствие одна из самых частых ошибок компиляции у новичков в C++.

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

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

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;
};

int main() {
    Point a{3, 4};        // x = 3, y = 4 (инициализация скобками, предпочтительно)
    Point origin{};       // оба поля инициализированы значением 0
    Point b = {10, 20};   // старая форма = {}, тот же эффект

    cout << a.x << "," << a.y << "\n";          // 3,4
    cout << origin.x << "," << origin.y << "\n"; // 0,0
    cout << b.x << "," << b.y << "\n";           // 10,20
}

Остерегайтесь пустого случая по умолчанию: Point p; (без скобок) оставляет x и y с мусорными значениями, потому что поля встроенных типов не обнуляются автоматически. Point p{}; инициализирует их значением 0. Предпочитайте скобки. Можно также зашить значения по умолчанию прямо в определение, чтобы даже Point p; начинал с чистого состояния:

#include <iostream>
using namespace std;

struct Config {
    int width  = 800;     // инициализаторы полей по умолчанию
    int height = 600;
    bool fullscreen = false;
};

int main() {
    Config c;             // использует все значения по умолчанию
    Config wide{1920};    // width переопределён, остальные сохраняют значения по умолчанию

    cout << c.width << "x" << c.height << "\n";        // 800x600
    cout << wide.width << "x" << wide.height << "\n";  // 1920x600
}

Структуры как параметры функций

Структура — это одно значение, поэтому функция может принимать один параметр вместо трёх. Только помните, что передача структуры по значению копирует все её поля. Для всего, что больше пары int'ов, передавайте по const-ссылке, чтобы избежать копирования — то же правило, которое вы видели на странице про ссылки.

#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    double gpa;
};

// const& избегает копирования строки и обещает не изменять s
void printStudent(const Student& s) {
    cout << s.name << ": " << s.gpa << "\n";
}

// возвращать структуру нормально - компилятор устраняет копирование
Student makeStudent(string name, double gpa) {
    return Student{name, gpa};
}

int main() {
    Student top = makeStudent("Grace", 4.0);
    printStudent(top);
}

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

Добавление методов и конструкторов

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

#include <iostream>
using namespace std;

struct Rectangle {
    double width;
    double height;

    // конструктор: выполняется при создании Rectangle
    Rectangle(double w, double h) : width(w), height(h) {}

    // метод: использует собственные поля объекта
    double area() const {        // const = "я не изменяю объект"
        return width * height;
    }
};

int main() {
    Rectangle r(4.0, 5.0);
    cout << "area = " << r.area() << "\n";   // area = 20
}

Внутри метода к полям обращаются по имени (width, height) — они ссылаются на копию этого объекта. Пометка area() const сообщает компилятору, что функция только читает объект, что позволяет вызывать её и для значений const Rectangle. Конструкторы — тема сама по себе, включая синтаксис списка инициализации : width(w); страница про конструкторы разбирает её подробно.

struct vs. class: настоящее различие

Возможно, вы слышали, что «структуры для данных, классы для объектов». Это соглашение, а не правило языка. В C++ struct и class почти одно и то же — единственное встроенное различие в уровне доступа по умолчанию.

struct S {
    int x;        // public по умолчанию
};

class C {
    int x;        // private по умолчанию
};

Поля struct являются public, если вы не пометите их иначе; поля class начинаются с private. Вот и всё — у обоих могут быть конструкторы, методы, наследование и всё остальное. Вы даже можете добавить структуре явные спецификаторы доступа, чтобы скрыть поля:

#include <iostream>
using namespace std;

struct Counter {
    int value() const { return count; }   // public
    void bump() { count++; }

private:
    int count = 0;                          // теперь скрыто
};

int main() {
    Counter c;
    c.bump();
    c.bump();
    cout << c.value() << "\n";   // 2
    // c.count = 99;   // ошибка компиляции - count приватный
}

Практический вывод: используйте struct для прозрачных наборов данных, где каждое поле предназначено для свободного доступа (Point, Color, запись конфигурации), и обращайтесь к class, когда хотите защитить внутреннее состояние за публичным интерфейсом. Компилятор обращается с ними одинаково; ключевое слово лишь сигнализирует о вашем намерении.

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

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

#include <iostream>
#include <vector>
#include <string>
using namespace std;

struct Product {
    string name;
    double price;
};

int main() {
    vector<Product> cart = {
        {"Keyboard", 49.99},
        {"Mouse", 19.99},
        {"Monitor", 199.00},
    };

    double total = 0;
    for (const Product& p : cart) {   // const& - без копирования на каждый элемент
        cout << p.name << ": $" << p.price << "\n";
        total += p.price;
    }
    cout << "Total: $" << total << "\n";
}

Обратите внимание на вложенные скобки: каждый {"Keyboard", 49.99} агрегатно инициализирует один Product, а внешние скобки строят вектор. Использование const Product& в цикле for по диапазону избавляет от копирования каждой структуры на каждой итерации — уберите &, и вы будете без нужды дублировать каждый элемент.

Далее: перечисления (Enums)

Структуры позволяют строить тип из нескольких объединённых значений. Следующая глава идёт в обратном направлении: перечисление (enum) определяет тип, который может содержать ровно одно значение из небольшого именованного набора — идеально для таких вещей, как Color::Red, Direction::North или статус конечного автомата. Вы увидите, как enum class даёт читаемые, типобезопасные константы, которые естественно сочетаются со структурами и классами, которые вы теперь создаёте.