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

Проще сделать:

typedef std::vector<MyObject> MyContainer;

В данном случае наследование - плохая идея: контейнеры STL не имеют виртуальных деструкторов, поэтому можно столкнуться с утечками памяти (к тому же, это говорит о том, что контейнеры 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;
}

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

Это статья под названием Gnome Panel Applets in Python от 2008 года на форумах Ubuntu, которая может помочь в этом.

Сюда входит определение компонента bonobo. В этой документации Gnome по разработке апплетов указано, что

Технически апплеты являются элементами управления Bonobo, встроенными в панель Gnome

. Таким образом, это правильный способ.

Altough window.onload будет соответствовать вашим потребностям, я бы рекомендовал немного ускорить процесс:

$("img.load").load(function(){
    alert($(this).width());
});

Теперь вы можете обрабатывать изображение индивидуально так же быстро, как оно загружено и не дожидаясь полного набора элементов.

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

SOLR не поддерживает обновление индивидуальных областей , но есть проблема Emira в этом (почти 3 года по настоящему письму).

До этого не будет реализован, вы должны обновить весь документ.

Обновление : в качестве Solr 4+ это реализовано, вот документация .

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

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

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. Единственный недостаток в том, что вы должны продлить интерфейс, если вы хотите использовать их с ассоциативными контейнерами. Я не столкнулся с необходимостью.