Защо векторът ще работи зле, ако наследи от него…

Наследяването от std::vector не се препоръчва поради липсата на виртуални деструктори и други виртуални функции, което нарушава принципа на подмяна на Лисков (LSP) и води до проблеми при полиморфното използване.

Примери за проблеми:

Проблем със среза (slicing): При предаване на обект от производен клас чрез стойност или препратка към базовия клас std::vector, данните и поведението, характерни за производния клас, се губят.

#include <vector>
#include <iostream>

class MyVector : public std::vector<int> {
public:
    int my_data = 100;
    // Без виртуален деструктор
    ~MyVector() {
        std::cout << "MyVector деструктор" << std::endl;
    }
};

void process_vector(std::vector<int> vec) {
    // Получава се по стойност - случва се срез
    // Деструкторът на MyVector няма да бъде извикан
    std::cout << "Обработка на std::vector" << std::endl;
}

int main() {
    MyVector mv;
    mv.push_back(1);
    process_vector(mv); // Случва се срез на обекта MyVector
    return 0;
} // Тук ще бъде извикан само деструкторът на std::vector

Липса на виртуален деструктор: Ако изтриете обект от производен клас чрез указател към базовия клас std::vector, деструкторът на производния клас няма да бъде извикан, което може да доведе до изтичане на ресурси.

#include <vector>
#include <iostream>
#include <memory> // За unique_ptr

class DerivedVector : public std::vector<int> {
public:
    int* resource;
    DerivedVector() : std::vector<int>(), resource(new int) {
        std::cout << "Конструктор DerivedVector" << std::endl;
    }
    // Липсва виртуален деструктор
    ~DerivedVector() {
        std::cout << "Деструктор DerivedVector" << std::endl;
        delete resource; // Може да не бъде извикан
    }
};

int main() {
    // Изтриване чрез указател към базовия клас
    std::vector<int>* base_ptr = new DerivedVector();
    // При delete base_ptr се извиква само деструкторът на std::vector,
    // деструкторът на DerivedVector не се извиква, има изтичане на ресурси
    delete base_ptr;

    // Пример с unique_ptr
    // std::unique_ptr<std::vector<int>> up = std::make_unique<DerivedVector>();
    // При излизане от scope, unique_ptr ще извика delete на raw указателя base_ptr.
    // Това е еквивалентно на delete base_ptr; и ще доведе до същия проблем, ако vector няма виртуален деструктор.

    return 0;
} // Паметта, заделена за resource, няма да бъде освободена

Конструктори: Поведението на конструкторите на std::vector (например, конструктор за копиране, преместване) може да не съответства на очакванията за производен клас, ако той добавя собствено състояние или логика.

Вместо наследяване от std::vector, най-добрите подходи са:

Композиция: Използвайте std::vector като член на класа. Това позволява да контролирате интерфейса и поведението на новия клас, като използвате std::vector вътре.

#include <vector>
#include <iostream>

class MyContainer {
private:
    std::vector<int> data;
    int my_extra_data = 100;
public:
    void add(int val) {
        data.push_back(val);
    }
    const std::vector<int>& get_data() const { // Предоставя достъп до вектора, ако е необходимо
        return data;
    }
    // Деструкторът на MyContainer ще извика правилно деструктора на data
    ~MyContainer() {
         std::cout << "Деструктор MyContainer" << std::endl;
    }
};

int main() {
    MyContainer mc;
    mc.add(1);
    std::cout << "Размер на данните: " << mc.get_data().size() << std::endl;
    return 0;
} // Деструкторът на MyContainer се извиква, който от своя страна извиква деструктора на std::vector

Свободни функции и алгоритми: Разширете функционалността на std::vector с помощта на обикновени функции или използвайте стандартните алгоритми.

Тези подходи са по-гъвкави, по-безопасни и съответстват на принципите на ООП и дизайна на библиотеки в C++. Стандартните контейнери не са предназначени за използване като базови класове.

Защо векторът ще работи зле, ако наследи от него?