Что такое агрегаты, тривиальные типы и POD в C++? Как они работают и зачем нужны?

Краткий ответ

Эти три понятия — агрегат, тривиальный тип и POD — описывают разные уровни «простоты» типа. Они определяют, можно ли с объектом работать как с куском памяти (копировать через memcpy), использовать в union или передавать в C-функции.

1. Агрегат (Aggregate)

Определение (C++17): Агрегат — это массив или класс (структура/класс) без:

• пользовательских конструкторов (кроме = default и = delete);
• закрытых/защищённых нестатических данных;
• виртуальных функций и виртуального наследования;
• базовых классов (в C++17; в C++11/14 разрешалось, но с ограничениями).

Главная фишка: Агрегаты можно инициализировать списком в фигурных скобках (aggregate init):

struct Point { int x; int y; };
Point p1 = {1, 2};  // aggregate initialization
Point p2{3, 4};     // тоже работает (C++11)

// НЕ агрегат:
struct NamedPoint {
    std::string name; // есть пользовательский конструктор у std::string
    int x, y;
};
// Нельзя: NamedPoint np = {"A", 1, 2}; — ошибка, если нет конструктора

2. Тривиальный тип (Trivial Type)

Тривиальный тип — это тип, у которого:

• тривиальный конструктор по умолчанию (не делает ничего или = default);
• тривиальный копирующий/перемещающий конструктор;
• тривиальный деструктор (не делает ничего);
• нет виртуальных функций/наследования.

Если тип тривиален, его объекты можно безопасно копировать через memcpy:

struct Trivial {
    int a;
    float b;
};
static_assert(std::is_trivial_v<Trivial>); // true

struct NonTrivial {
    std::vector<int> v; // нетривиальный деструктор
};
static_assert(std::is_trivial_v<NonTrivial>); // false

// Копирование через memcpy:
Trivial t1{1, 2.0f};
Trivial t2;
std::memcpy(&t2, &t1, sizeof(Trivial)); // OK для тривиальных

3. POD (Plain Old Data)

POD = тривиальный + стандартная компоновка (standard-layout). Стандартная компоновка означает:

• все нестатические поля имеют одинаковый доступ (public);
• нет виртуальных функций/наследования;
• первый член структуры расположен по тому же адресу, что и сама структура.

POD-типы совместимы с C (можно передавать в C-функции, использовать в union):

struct Pod {
    int x;
    double y;
}; // POD — тривиальный + standard-layout

union MyUnion {
    int i;
    Pod p; // только POD-типы можно хранить в union до C++11
};

4. Зачем это нужно?

• Производительность: Тривиальные типы можно копировать memcpy вместо вызова конструкторов.
• Совместимость с C: POD-типы можно передавать через границу C/C++.
• Оптимизации компилятора: Агрегаты и тривиальные типы позволяют компилятору генерировать более эффективный код.

5. Изменения в C++20

В C++20 агрегаты могут иметь пользовательские конструкторы, объявленные как = default или = delete, а также виртуальные функции (но тогда они не будут тривиальными).

Проверка в коде:

#include <type_traits>
struct S { int a; };
static_assert(std::is_aggregate_v<S>);     // true
static_assert(std::is_trivial_v<S>);       // true
static_assert(std::is_pod_v<S>);          // true (устарело в C++20)

Резюме

• Агрегат — можно инициализировать списком.
• Тривиальный — можно копировать через memcpy.
• POD = тривиальный + стандартная компоновка = совместимость с C.

// Хорошо (POD):
struct Vec3 { float x, y, z; };

// Плохо (не POD, хотя может быть агрегатом):
struct Vec3Bad {
    float x, y, z;
    std::string debug_name; // нарушает тривиальность
};