Почему все функции <алгоритма> принимают только диапазоны, а не контейнеры?

Есть много полезных функций <algorithm>, но все они работают с «последовательностями» - парами итераторов. Например, если у меня есть контейнер и мне нравится работать std::accumulateна нем, мне нужно написать:

std::vector<int> myContainer = ...;
int sum = std::accumulate(myContainer.begin(), myContainer.end(), 0);

Когда все, что я собираюсь сделать, это:

int sum = std::accumulate(myContainer, 0);

Что немного более читабельно и понятно в моих глазах.

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

Это легко написать функцию - обертку , которая принимает контейнер и звонки begin()и end()на ней, но такие функции удобства не входят в стандартную библиотеку.

Я хотел бы знать причину этого выбора дизайна STL.

... безусловно, полезно иметь возможность проходить диапазоны. Но, по крайней мере, по моему опыту, это редкий особый случай. Я обычно хочу работать с целыми контейнерами

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

Вы уже заметили, что можете реализовать весь контейнерный случай, используя текущий интерфейс, но вы не можете сделать обратное.

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

Легко написать функцию-обертку, которая принимает контейнер и вызывает на нем begin () и end (), но такие вспомогательные функции не включены в стандартную библиотеку

Правда, тем более что бесплатные функции std::beginи std::endсейчас включены.

Итак, допустим, библиотека обеспечивает перегрузку удобства:

template <typename Container>
void sort(Container &c) {
  sort(begin(c), end(c));
}

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

Но мы по крайней мере рассмотрели каждый случай, когда мы хотим работать с полным контейнером, верно? Ну, не совсем. Рассмотреть возможность

std::for_each(c.rbegin(), c.rend(), foo);

Если мы хотим работать с контейнерами в обратном направлении , нам нужен другой метод (или пара методов) для каждого существующего алгоритма.

Таким образом, основанный на диапазоне подход является более общим в простом смысле:

• он может делать все, что может версия целого контейнера
• подход с использованием целых контейнеров удваивает или утраивает количество требуемых перегрузок, оставаясь при этом менее мощным
• основанные на диапазоне алгоритмы также можно компоновать (вы можете использовать адаптеры итераторов в стеке или в цепочке, хотя чаще это делается на функциональных языках и Python)

Конечно, есть еще одна веская причина, заключающаяся в том, что для стандартизации STL было уже очень много работы, и накачка его удобными обертками до того, как он стал широко использоваться, не будет большим использованием ограниченного времени для комитетов. Если вы заинтересованы, вы можете найти технический отчет Stepanov & Lee здесь

Как уже упоминалось в комментариях, Boost.Range предоставляет новый подход, не требуя изменений в стандарте.

Оказывается, есть статья Херба Саттера на эту самую тему. По сути, проблема заключается в неоднозначности перегрузки. Учитывая следующее:

template<typename Iter>
void sort( Iter, Iter ); // 1

template<typename Iter, typename Pred>
void sort( Iter, Iter, Pred ); // 2

И добавив следующее:

template<typename Container>
void sort( Container& ); // 3

template<typename Container, typename Pred>
void sort( Container&, Pred ); // 4

Будет трудно отличить 4и 1правильно.

Концепции, предложенные, но в конечном счете не включенные в C ++ 0x, решили бы это, и также возможно обойти это, используя enable_if. Для некоторых алгоритмов это не проблема. Но они решили против этого.

Теперь, после прочтения всех комментариев и ответов здесь, я думаю, что rangeобъекты будут лучшим решением. Я думаю, что я посмотрю Boost.Range.

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

Но да, в ретроспективе решение неверно. Мы были бы лучше с объектом диапазона построимого от любого begin/endили begin/length; теперь у нас есть несколько _nсуффиксных алгоритмов.

Добавление их не даст вам никакой силы (вы уже можете сделать весь контейнер, позвонив .begin()и .end()себе), и это добавит еще одну вещь в библиотеку, которая должна быть правильно указана, добавлена ​​в библиотеки поставщиками, протестирована, поддерживается, и т. д.

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

К настоящему моменту http://en.wikipedia.org/wiki/C++11#Range-based_for_loop - хорошая альтернатива std::for_each. Обратите внимание, нет явных итераторов:

int a[5] = {1, 2, 3, 4, 5};
for (auto &i: a) { i *= 2; }

(Вдохновлено https://stackoverflow.com/a/694534/2097284 .)