Можно ли наследовать реализацию от контейнеров STL, а не делегировать?

вы можете объединить частное наследование и ключевое слово "using", чтобы обойти большинство проблем, упомянутых выше: частное наследование "реализовано в терминах", и поскольку оно является частным, вы не можете удерживать указатель на базовый класс

#include <string>
#include <iostream>

class MyString : private std::string
{
public:
    MyString(std::string s) : std::string(s) {}
    using std::string::size;
    std::string fooMe(){ return std::string("Foo: ") + *this; }
};

int main()
{
    MyString s("Hi");
    std::cout << "MyString.size(): " << s.size() << std::endl;
    std::cout << "MyString.fooMe(): " << s.fooMe() << std::endl;
}

как все уже заявили, контейнеры STL не имеют виртуальных деструкторов, поэтому наследование от них в лучшем случае небезопасно. Я всегда рассматривал общее Программирование с шаблонами как другой стиль OO - one без наследования. Алгоритмы определяют интерфейс, который им требуется. Это как можно ближе к Утиной Типизацией как вы можете получить в статический язык.

в любом случае, у меня есть что добавить к обсуждению. То, как я создал свой собственный шаблон специализации ранее заключается в определении классов, как показано ниже, чтобы использовать в качестве базовых классов.

template <typename Container>
class readonly_container_facade {
public:
    typedef typename Container::size_type size_type;
    typedef typename Container::const_iterator const_iterator;

    virtual ~readonly_container_facade() {}
    inline bool empty() const { return container.empty(); }
    inline const_iterator begin() const { return container.begin(); }
    inline const_iterator end() const { return container.end(); }
    inline size_type size() const { return container.size(); }
protected: // hide to force inherited usage only
    readonly_container_facade() {}
protected: // hide assignment by default
    readonly_container_facade(readonly_container_facade const& other):
        : container(other.container) {}
    readonly_container_facade& operator=(readonly_container_facade& other) {
        container = other.container;
        return *this;
    }
protected:
    Container container;
};

template <typename Container>
class writable_container_facade: public readable_container_facade<Container> {
public:
    typedef typename Container::iterator iterator;
    writable_container_facade(writable_container_facade& other)
        readonly_container_facade(other) {}
    virtual ~writable_container_facade() {}
    inline iterator begin() { return container.begin(); }
    inline iterator end() { return container.end(); }
    writable_container_facade& operator=(writable_container_facade& other) {
        readable_container_facade<Container>::operator=(other);
        return *this;
    }
};

эти классы предоставляют тот же интерфейс, что и контейнер STL. Мне нравится эффект разделения модифицируемые и немодифицируемые операций в различных базовых классов. Это очень хорошо влияет на const-корректность. Один недостаток заключается в том, что вам нужно расширить интерфейс, если вы хотите использовать их с ассоциативными контейнерами. Я не столкнулся с необходимостью хотя.

в этом случае наследование-плохая идея: контейнеры STL не имеют виртуальных деструкторов, поэтому вы можете столкнуться с утечками памяти (кроме того, это указывает на то, что контейнеры STL не предназначены для наследования в первую очередь).

Если вам просто нужно добавить некоторую функциональность, вы можете объявить ее в глобальных методах или в облегченном классе с указателем/ссылкой на член контейнера. Это, конечно, не позволяет вам скрывать методы: если это действительно то, что вам нужно, то нет другого варианта, чем повторное объявление всей реализации.

виртуальные dtors в сторону, решение наследовать по сравнению с contain должно быть проектным решением на основе класса, который вы создаете. Вы никогда не должны наследовать функциональность контейнера только потому, что это проще, чем содержать контейнер и добавлять несколько функций добавления и удаления, которые кажутся упрощенными оболочками если вы можете окончательно сказать, что класс, который вы создаете, является своего рода контейнером. Например, класс classroom часто содержит объекты student, но a класс не является своего рода списком студентов для большинства целей, поэтому вы не должны наследовать от списка.

это проще сделать:

typedef std::vector<MyObject> MyContainer;

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