Что такое POD-типы в C++ и зачем они нужны?

Что такое POD-типы?

В современном C++ (начиная с C++11) термин POD (Plain Old Data) формально разделён на две независимые концепции: тривиально копируемый тип (trivially copyable) и тип со стандартной компоновкой (standard layout). POD — это тип, который соответствует обоим этим требованиям.

1. Тривиально копируемый тип

Это значит, что объект можно безопасно копировать побайтово (через memcpy) в другой массив байт или в существующий объект, и результат будет корректным. Такой тип:

• Не имеет виртуальных функций и виртуальных базовых классов
• Не имеет пользовательских конструкторов копирования/перемещения/деструктора (или они = default и тривиальны)
• Все нестатические члены тоже тривиально копируемы

2. Тип со стандартной компоновкой

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

• Не имеет виртуальных функций/базовых классов
• Все нестатические члены имеют одинаковый доступ (все public или все private)
• Не содержит ссылок
• Имеет тривиальные конструкторы/деструкторы

Примеры и разбор

Ваш Point — POD:

struct Point {
    int x;   // тривиальный тип
    int y;   // тривиальный тип
    // нет виртуальных функций, нет пользовательских конструкторов
};
// Это POD: тривиально копируемый + стандартная компоновка

Person — НЕ POD, потому что std::string:

struct Person {
    std::string name; // НЕ тривиально копируемый (содержит указатели, динамическую память)
    int age;
};
// Копирование через memcpy приведёт к утечке памяти или двойному удалению!

Где это нужно на практике?

1. Безопасное копирование через memcpy

Point p1{10, 20};
Point p2;
std::memcpy(&p2, &p1, sizeof(Point)); // OK для POD
// Теперь p2.x == 10, p2.y == 20

Person person1{"Alice", 30};
Person person2;
// std::memcpy(&person2, &person1, sizeof(Person)); // ОПАСНО! Неопределённое поведение!

2. Использование в union

union Data {
    int i;
    float f;
    Point p; // Point - POD, поэтому можно
    // Person p; // Ошибка! Person не POD
};

3. Ввод-вывод бинарных данных

// Запись POD-структуры в файл
Point data[100];
std::ofstream file("points.bin", std::ios::binary);
file.write(reinterpret_cast<char*>(data), sizeof(data)); // Безопасно для POD

4. Взаимодействие с C-кодом

// C-функция ожидает struct с определённой памятью
extern "C" void process_point(const Point* p); // Point - POD, можно передавать

5. Шаблонное программирование

template<typename T>
void fast_copy(T* dst, const T* src, size_t n) {
    if constexpr (std::is_trivially_copyable_v<T>) {
        std::memcpy(dst, src, n * sizeof(T)); // Быстрое копирование
    } else {
        for (size_t i = 0; i < n; ++i) dst[i] = src[i]; // Поэлементное
    }
}

Как проверить в коде?

#include <type_traits>

static_assert(std::is_pod_v<Point>, "Point должен быть POD");
static_assert(!std::is_pod_v<Person>, "Person не POD");

В C++20 появился концепт std::is_standard_layout_v и std::is_trivially_copyable_v, которые используются чаще, чем устаревший std::is_pod.

std::vector<Point> v1(1000);
std::vector<Person> v2(1000);

// При реаллокации вектора:
// Для Point - memcpy (быстро)
// Для Person - вызов конструкторов копирования (медленно)

Point p; // НЕ инициализировано (мусор), но быстро
Person p2; // name инициализируется пустой строкой (медленнее)

// Для POD можно явно обнулить:
Point p_zero{}; // x=0, y=0