Наследование в C++: public, private, protected и производительность

Что скрывается за модификаторами наследования в C++?

Представьте, что вы архитектор. У вас есть чертеж "здания" (базовый класс), и вы хотите построить по нему три разных "дома" (производных класса). Один дом будет точной копией с публичным входом (public), второй — с закрытым внутренним двором (private), а третий — с доступом только для семьи и друзей (protected). В C++ именно так работают модификаторы наследования. Но влияет ли этот выбор на скорость работы программы? Спойлер: и да, и нет. Давайте разберемся, как не выстрелить себе в ногу и заодно оптимизировать код.

Этот вопрос — один из самых популярных на Stack Overflow (десятки тысяч просмотров), и не зря. Новички часто путают уровень доступа к членам класса и тип наследования. А опытные разработчики знают: правильный выбор наследования может сэкономить часы дебага и даже немного ускорить программу. Сегодня на pythonlib.ru мы закроем эту тему раз и навсегда.

Треугольник наследования: public, private, protected

Для начала — база. Представьте, что у нас есть базовый класс Animal:

class Animal {
public:
    void eat() { /* ... */ }
protected:
    int age;
private:
    std::string secretDNA;
};

Теперь посмотрим, как три типа наследования меняют доступ к этим членам в производном классе Dog.

1. Public наследование — «как есть»

Самый распространенный и интуитивный тип. Все уровни доступа остаются без изменений:

• public → public (доступно всем)
• protected → protected (доступно наследникам)
• private → недоступно (остается в базовом классе)

Используйте, когда хотите выразить отношение "Dog IS-A Animal". Это классическое ООП.

2. Protected наследование — «только для своих»

Все public-члены базового класса становятся protected в производном:

• public → protected
• protected → protected
• private → недоступно

Нужно, когда вы хотите скрыть детали реализации от внешнего мира, но разрешить доступ "внукам". Например, библиотека Boost активно использует protected наследование для внутренних механизмов.

3. Private наследование — «мое и только мое»

Самый строгий режим. Все public и protected члены становятся private:

• public → private
• protected → private
• private → недоступно

Это отношение "Dog реализован ЧЕРЕЗ Animal". Часто используется вместо композиции для оптимизации (об этом ниже).

Производительность: где собака зарыта?

А теперь — к главному интригующему вопросу: влияет ли тип наследования на производительность? Если коротко: напрямую — нет, но косвенно — очень даже.

Миф: private наследование быстрее public

Некоторые думают, что private наследование "убирает лишние проверки". Это неправда. Модификаторы доступа (public, protected, private) — это чисто compile-time концепция. Компилятор проверяет их на этапе сборки и генерирует одинаковый машинный код. Разницы в рантайме нет.

Реальность: оптимизация через empty base optimization (EBO)

Вот где private наследование реально ускоряет программу! Если базовый класс не содержит данных (пустой класс), то при public или protected наследовании компилятор может (но не обязан) добавить лишний байт для выравнивания. А при private наследовании срабатывает Empty Base Optimization (EBO) — размер объекта не увеличивается.

Пример:

class EmptyAllocator { /* нет членов */ };

// Вариант 1: public наследование
template<typename T>
class Vector : public EmptyAllocator {
    T* data;
    size_t size;
    // sizeof(Vector) может быть 16 (из-за выравнивания)
};

// Вариант 2: private наследование + EBO
template<typename T>
class Vector : private EmptyAllocator {
    T* data;
    size_t size;
    // sizeof(Vector) = 12 (если указатель 4 байта, size_t 4 байта)
};

В стандартной библиотеке C++ (STL) это используется повсеместно. Например, std::unique_ptr с пользовательским deleter'ом использует private наследование для EBO. Это реальная оптимизация памяти и кэша!

Virtual таблицы: неожиданный поворот

А вот virtual-наследование — совсем другая история. Оно добавляет накладные расходы (дополнительные указатели vtable, замедление при вызове методов). Но это не связано с модификаторами public/private/protected. Virtual — это отдельный модификатор. Запомните: class Dog : public virtual Animal — это не про доступ, а про ромбовидное наследование.

Практические советы по оптимизации

Как выбрать правильное наследование, чтобы код был и быстрым, и красивым?

• Для полиморфизма — только public. Если вы планируете использовать объект через указатель на базовый класс (виртуальные функции), другого варианта нет.
• Для реализации "черного ящика" — private. Если вы наследуетесь только для переиспользования кода, а не для полиморфизма, private даст EBO и скроет детали.
• Для библиотек с глубокой иерархией — protected. Когда нужно, чтобы "внуки" имели доступ к методам, но внешний мир — нет.
• Избегайте virtual наследования без крайней необходимости. Оно замедляет вызовы и увеличивает размер объектов на 10-30%.

Пример из реального кода: аллокатор памяти

Давайте напишем мини-аллокатор, где оптимизация через private наследование критична:

// Пустой политика аллокации
struct MallocPolicy {
    void* allocate(size_t size) { return malloc(size); }
    void deallocate(void* p) { free(p); }
};

// Класс-обертка с private наследованием для EBO
template<typename T, typename AllocPolicy = MallocPolicy>
class FastArray : private AllocPolicy {
    T* data;
    size_t count;
public:
    FastArray(size_t n) : count(n) {
        data = static_cast<T*>(AllocPolicy::allocate(n