Понятие C++ проверяет по сравнению с наследованием

Я думаю о понятиях как своего рода метаинтерфейс. Они категоризируют типы после своих способностей. Следующая версия C++ предоставляет собственные понятия. Я не понял это, пока я не столкнулся с C++ 1x's понятия и как они позволяют соединять различные все же несвязанные типы. Предположите, что у Вас есть a Range интерфейс. Можно смоделировать это с двумя путями. Каждый - отношения подтипа:

class Range {
    virtual Iterator * begin() = 0;
    virtual Iterator * end() = 0;

    virtual size_t size() = 0;
};

Конечно, каждый класс, который происходит из этого, реализует интерфейс Range и может использоваться с Вашими функциями. Но теперь Вы видите, что это ограничено. Что относительно массива? Это - диапазон также!

T t[N];

begin() => t
end() => t + size()
size() => N

К сожалению, Вы не можете получить массив из того класса Диапазона, реализовав тот интерфейс. Вам нужен дополнительный метод (перегрузка). И что относительно сторонних контейнеров? Пользователь Вашей библиотеки мог бы хотеть использовать их контейнеры вместе с Вашими функциями. Но он не может изменить определение их контейнеров. Здесь, понятия входят в игру:

auto concept Range<typename T> {
    typename iterator;
    iterator T::begin();
    iterator T::end();
    size_t T::size();
}

Теперь, Вы говорите что-то о поддерживаемых операциях некоторого типа, который может быть выполнен если T имеет соответствующие функции членства. В Вашей библиотеке Вы записали бы функциональный дженерик. Это позволяет Вам, принимают любой тип, пока он поддерживает необходимые операции:

template<Range R>
void assign(R const& r) {
    ... iterate from r.begin() to r.end(). 
}

Это - большой вид замещаемости. Любой тип будет отвечать всем требованиям, который придерживается понятия и не только тех типов, которые активно реализуют некоторый интерфейс. Следующий Стандарт C++ идет далее: Это определяет a Container понятие, которое будет пригодно простыми массивами (чем-то названным картой понятия, которая определяет, как некоторый тип соответствует некоторому понятию), и другой, существующие стандартные контейнеры.

Причина, почему я поднимаю это, состоит в том, потому что у меня есть шаблонный контейнер, где сами контейнеры имеют иерархические отношения. Я хотел бы записать алгоритмы, которые используют эти контейнеры, не заботясь, о котором определенном контейнере это. Кроме того, некоторые алгоритмы извлекли бы выгоду из знания, что шаблонный тип удовлетворил определенные понятия (Сопоставимый, например).

Можно на самом деле сделать обоих с шаблонами. Можно продолжать иметь иерархические отношения, чтобы совместно использовать код и затем записать алгоритмы универсальным способом. Например, для передачи того контейнера сопоставимо. Это похоже на стандартные категории итератора произвольного доступа/вперед/вывода/входа, реализованы:

// tag types for the comparator cagetory
struct not_comparable { };
struct basic_comparable : not_comparable { };

template<typename T>
class MyVector : public BasicContainer<T> {
    typedef basic_comparable comparator_kind;
};

/* Container concept */
T::comparator_kind: comparator category

Это - разумный простой способ сделать это на самом деле. Теперь можно вызвать функцию, и она передаст корректной реализации.

template<typename Container>
void takesAdvantage(Container const& c) {
    takesAdvantageOfCompare(c, typename Container::comparator_kind());
}

// implementation for basic_comparable containers
template<typename Container>
void takesAdvantage(Container const& c, basic_comparable) {
    ...
}

// implementation for not_comparable containers
template<typename Container>
void takesAdvantage(Container const& c, not_comparable) {
    ...
}

Существуют на самом деле различные методы, которые могут использоваться для реализации этого. Иначе должен использовать boost::enable_if включить или отключить различные реализации каждый раз.