Идиома Empty Base Optimization в C++: Как пустые классы помогают экономить память

Когда мы пишем программы на C++, мы хотим, чтобы они работали быстро и использовали поменьше памяти. Оказывается, даже пустые классы могут помочь нам в этом!

В этой статье разберем, что такое Empty Base Optimization (EBO) — оптимизация пустых базовых классов — и как она делает программы эффективнее.

Что такое пустой класс?

Для начала разберемся с главным понятием.

Пустой класс — это класс, у которого нет никаких данных внутри. Например:

struct Empty {

// Здесь нет переменных-членов

};

Казалось бы, раз класс пустой, он не должен занимать память. Но в C++ есть важное правило: каждый объект должен иметь уникальный адрес. Поэтому даже пустой объект занимает минимум 1 байт (чтобы у него был адрес).

Empty e;

std::cout << sizeof(e); // Выведет 1 (на большинстве компиляторов)

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

struct Empty {};

struct Derived : Empty {

int x; // 4 байта

};

Без оптимизации объект Derived занимал бы:

- 1 байт для Empty (чтобы был уникальный адрес)

- 4 байта для x

- + возможно выравнивание (padding)

Итого: 8 байт.

Благодаря EBO компилятор понимает: "А зачем выделять память под Empty, если от него все равно ничего не нужно?" И размер Derived становится просто 4 байта — ровно столько, сколько занимает x.

Разработчики стандартной библиотеки C++ активно используют EBO, чтобы программы работали эффективнее. Давайте посмотрим на несколько примеров.

Пример 1: std::tuple

std::tuple может хранить несколько значений разных типов. Благодаря EBO, если один из типов пустой, он не занимает лишнего места:

#include <tuple>

#include <iostream>

struct Empty {};

int main() {

std::tuple<Empty, int> t;

std::cout << sizeof(t); // Скорее всего, выведет 4, а не 8!

}

Пример 2 std::function

std::function может хранить любые вызываемые объекты: функции, лямбды, функторы. Если вызываемый объект пустой (например, лямбда без захвата переменных), std::function не будет хранить лишних данных:

#include <functional>

#include <iostream>

struct SimpleFunc {

void operator()() const {} // Пустой функтор

};

int main() {

std::function<void()> f = SimpleFunc{};

std::cout << sizeof(f); // Размер будет маленьким (может быть даже 1!)

}

Пример 3: std::shared_ptr

У std::shared_ptr есть настраиваемый удалитель (deleter) — объект, который решает, как освобождать память. Если удалитель пустой, он не увеличивает размер умного указателя:

#include <memory>

#include <iostream>

struct EmptyDeleter {

void operator()(void*) {} // Ничего не делает

};

int main() {

std::shared_ptr<int> ptr(new int(42), EmptyDeleter{});

std::cout << sizeof(ptr); // Размер такой же, как с обычным удалителем

}

EBO особенно полезен при использовании политик (policies) — шаблонного проектирования, когда поведение класса настраивается через параметры шаблона.

template <typename Policy>

class DataProcessor : private Policy { // Приватное наследование для EBO

int data;

public:

DataProcessor(int d) : data(d) {}

void process() {

Policy::process(data); // Используем политику

}

};

// Пустая политика — просто способ обработки данных

struct DoublePolicy {

static void process(int& x) { x *= 2; }

};

int main() {

DataProcessor<DoublePolicy> proc(10);

proc.process(); // data станет 20

std::cout << sizeof(proc); // Выведет 4 (только размер int)!

}

Обратите внимание: мы использовали приватное наследование, а не включение политики как поля. Если бы мы сделали так:

template <typename Policy>

class DataProcessor {

Policy policy; // Поле, а не базовый класс

int data;

// ...

};

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

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

Empty Base Optimization — это пример того, как даже небольшие хитрости компилятора могут экономить память в больших проектах. Особенно это важно в шаблонном коде, где пустые классы-политики встречаются очень часто.

Главное:

- Пустые классы занимают 1 байт, если создавать их объекты

- Но если от них наследоваться, компилятор может не выделять память

- Это позволяет писать гибкий код без потери производительности