Как запретить наследование от класса?

Как запретить наследование от класса в C++

Способ 1: final спецификатор (C++11+) — ЛУЧШИЙ

Это самый простой и читаемый способ:

// Запрещаем наследование
class Base final {
public:
    void method() { }
};

// ❌ Ошибка компиляции
class Derived : public Base {  // error: Base is marked 'final'
    // ...
};

Этот способ:

• Ясен и явен
• Проверяется на compile-time
• Современен (C++11 и выше)
• Читаемый код

Способ 2: Приватный конструктор (для template классов)

Не работает с обычными классами, но полезно в шаблонах:

template <typename T>
class NonDerivable {
public:
    NonDerivable() = default;
    
private:
    // Приватный деструктор
    ~NonDerivable() { }
};

// ❌ Ошибка: попытка вызвать приватный деструктор
class Derived : public NonDerivable<int> { };

Этот способ работает, но:

• Нечитаемо
• Ошибка появляется непредсказуемо
• Не рекомендуется

Способ 3: CRTP (Curiously Recurring Template Pattern)

Продвинутая техника для шаблонных классов:

template <typename T>
class NonDerivable {
public:
    NonDerivable() {
        // Проверяем, что T == конкретный класс
        static_assert(
            std::is_same_v<T, std::remove_cv_t<T>>,
            "Cannot derive from NonDerivable"
        );
    }
};

class MyClass : public NonDerivable<MyClass> { };  // ✅ OK

class Derived : public MyClass { };  // ✅ OK (MyClass от NonDerivable)

Этот способ:

• Работает с шаблонами
• Но сложный и нечитаемый
• Редко используется

Практические примеры

Пример 1: Запрещаем наследование от строки

class String final {
private:
    char* data;
    size_t length;
    
public:
    String(const char* str) { }
    ~String() { delete[] data; }
};

// ❌ Ошибка компиляции
class MyString : public String {
    // error: base class String is final
};

Пример 2: Конкретный класс в иерархии

class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() = default;
};

// Промежуточный класс
class Polygon : public Shape {
public:
    void draw() override { }
};

// ФИНАЛЬНЫЙ класс — запрещаем наследование
class Triangle final : public Polygon {
public:
    void draw() override { std::cout << "Drawing triangle\n"; }
};

// ❌ Ошибка компиляции
class EquilateralTriangle : public Triangle {
    // error: base class Triangle is final
};

Пример 3: Многоуровневая иерархия

class Animal {
public:
    virtual void speak() = 0;
};

class Mammal : public Animal {
public:
    void speak() override { std::cout << "Some sound\n"; }
};

class Dog final : public Mammal {
public:
    void speak() override { std::cout << "Woof!\n"; }
};

// ❌ Нельзя наследоваться от Dog
class GoldenRetriever : public Dog { };  // error: Dog is final

Когда нужно запретить наследование?

1. Классы с не-виртуальными деструкторами

class Base {
public:
    // Нет virtual ~Base() !!!
    ~Base() { std::cout << "Deleted\n"; }
};

class Derived : public Base {
public:
    Derived() { data = new int[1000]; }
    ~Derived() { delete[] data; }
private:
    int* data;
};

int main() {
    Base* ptr = new Derived();
    delete ptr;  // ❌ Вызовет Base::~Base(), не Derived::~Derived()
    // Утечка памяти!
}

// Решение: Base должен быть final или иметь virtual деструктор
class Base final {  // ✅ Теперь Derived не может наследоваться
    // ...
};

2. Классы с уникальной логикой, которая не должна переопределяться

class ThreadPool final {
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex mutex;
    std::condition_variable cv;
    bool stop = false;
    
public:
    // Сложная синхронизация, которая не должна переопределяться
    void enqueue(std::function<void()> task) {
        std::lock_guard<std::mutex> lock(mutex);
        tasks.push(task);
        cv.notify_one();
    }
};

// ❌ Нельзя наследоваться и нарушить синхронизацию
class MyThreadPool : public ThreadPool { };

3. Классы-синглтоны

class Logger final {
private:
    static Logger* instance;
    Logger() { }  // Приватный конструктор
    
public:
    static Logger* getInstance() {
        if (!instance) {
            instance = new Logger();
        }
        return instance;
    }
    
    void log(const std::string& message) {
        std::cout << "[LOG] " << message << "\n";
    }
};

// ❌ Нельзя наследоваться
class MyLogger : public Logger { };

4. API для публичной библиотеки

// PublicAPI.h
class APIv2 final {
public:
    void execute(const Request& req) { }
    // Гарантируем, что версия API не будет нарушена
};

// ❌ Пользователи не могут изменить логику API
class MyAPI : public APIv2 { };

Сравнение методов

Ошибка: final + virtual

class Base {
public:
    virtual void method() { }
};

// ✅ Можем запретить наследование
class Final : public Base final {
public:
    void method() override { }  // virtual переопределение OK
};

// ❌ Нельзя наследоваться
class Attempt : public Final { };  // error: Final is final

Частый вопрос: "Нужен ли virtual деструктор если класс final?"

class Base final {
public:
    ~Base() { }  // Может быть non-virtual
};

// Так как нельзя наследоваться, нет риска вызвать неправильный деструктор
Base* ptr = new Base();
delete ptr;  // Вызовет Base::~Base()

НО если базовый класс не final и он содержит virtual методы:

class Base {  // Не final, есть virtual методы
public:
    virtual void method() = 0;
    virtual ~Base() = default;  // ✅ Нужен virtual деструктор
};

class Derived : public Base {
public:
    void method() override { }
    ~Derived() { delete[] data; }  // Вызовется через virtual
private:
    int* data = new int[100];
};

Заключение

• Используй final спецификатор для запрещения наследования
• Это явно, читаемо и проверяется на compile-time
• Запрещай наследование когда:
  • Класс имеет non-virtual деструктор
  • Логика класса не предполагает переопределение
  • Это API, версия которого не должна меняться
• Избегай старых способов (приватный конструктор) — они запутаны
• final — это инструмент проектирования, указывающий на намерение