В чем разница между public, protected и private наследованием в C++?

Краткая суть: как работают спецификаторы наследования

В C++ наследование бывает трех видов: public, protected и private. Они определяют, как члены базового класса (поля и методы) будут видны в классе-наследнике и за его пределами. Главное правило: спецификатор наследования "понижает" уровень доступа унаследованных членов.

Вот таблица для запоминания:

• public наследование — сохраняет исходные уровни доступа (pub→pub, prot→prot, priv→недоступен).
• protected наследование — все public члены становятся protected в наследнике (pub→prot, prot→prot, priv→недоступен).
• private наследование — все public и protected члены становятся private (pub→priv, prot→priv, priv→недоступен).

Важно: private члены базового класса никогда не доступны напрямую в наследнике, независимо от типа наследования. Доступ к ним возможен только через public/protected методы базового класса.

Пример кода для наглядности

class Base {
public:
    int pub = 1;
protected:
    int prot = 2;
private:
    int priv = 3;
};

// Public наследование
class PubDerived : public Base {
    void func() {
        pub = 10;   // ✅ OK: pub остаётся public
        prot = 20;  // ✅ OK: prot остаётся protected
        // priv = 30; // ❌ Ошибка: priv недоступен
    }
};

// Protected наследование
class ProtDerived : protected Base {
    void func() {
        pub = 10;   // ✅ OK: pub стал protected
        prot = 20;  // ✅ OK: prot остаётся protected
        // priv = 30; // ❌ Ошибка
    }
};

// Private наследование (по умолчанию для class)
class PrivDerived : private Base {
    void func() {
        pub = 10;   // ✅ OK: pub стал private
        prot = 20;  // ✅ OK: prot стал private
        // priv = 30; // ❌ Ошибка
    }
};

int main() {
    PubDerived pd;
    pd.pub = 5;  // ✅ OK: pub — public
    // pd.prot = 5; // ❌ Ошибка: prot — protected

    ProtDerived ptd;
    // ptd.pub = 5; // ❌ Ошибка: pub стал protected

    PrivDerived prd;
    // prd.pub = 5; // ❌ Ошибка: pub стал private
}

Когда что использовать?

• public наследование — стандартный вариант. Означает "is-a" (наследник является разновидностью базового класса). Используется в 95% случаев.
• protected наследование — редко. Нужно, когда вы хотите скрыть наследование от внешнего мира, но разрешить доступ своим наследникам. Например, для внутренней реализации.
• private наследование — означает "реализовано через". Используется для композиции (когда наследник использует функционал базового класса, но не является им). Пример: класс Stack, наследующий от vector приватно.

Важное замечание про struct vs class

У struct и class разный доступ по умолчанию:

struct A : Base { };  // public наследование по умолчанию
class B : Base { };   // private наследование по умолчанию

Поэтому всегда лучше явно указывать спецификатор наследования, чтобы код был понятнее.

Надеюсь, теперь стало яснее! Если остались вопросы — спрашивайте.

class Base {
public:
    void publicMethod() {}
protected:
    void protectedMethod() {}
private:
    void privateMethod() {}
};

class Derived : private Base {
public:
    void test() {
        publicMethod();    // ✅ Стал private, но внутри класса доступен
        protectedMethod(); // ✅ Тоже стал private
        // privateMethod(); // ❌ Никогда не доступен
    }
};

int main() {
    Derived d;
    // d.publicMethod(); // ❌ Ошибка: стал private
}

class Base {
protected:
    void foo() {}
};

class Derived : private Base {
public:
    using Base::foo; // Делаем foo публичным в наследнике
};