ОКСИМОРОН (оксюморон) (греческое oxymoron, буквально — остроумно-глупое), стилистическая фигура, сочетание противоположных по значению слов, сжатая и оттого парадоксально звучащая антитеза ("живой труп" — Л.Н. Толстой; "жар холодных числ" — А.А. Блок, "итератор произвольного доступа" — А. Степанов).

V>> Кстати, а не трудно тебе сформулировать, что ты называешь прямым доступом применительно к итератору? Может вообще весь этот спор ни о чем...

дополнительные операции итератора.
Минимальный интерфейс класса
Iterator состоит из операций First, Next, IsDone и Currentltem.1 Но
могут оказаться полезными и некоторые дополнительные операции. Напри-
мер, упорядоченные агрегаты могут предоставлять операцию Previous, по-
зиционирующую итератор на предыдущий элемент. Для отсортированных
или индексированных коллекций интерес представляет операция SkipTo,
которая позиционирует итератор на объект, удовлетворяющий некоторому
критерию;

использование полиморфных итераторов в C++.
С полиморфными итерато-
рами связаны определенные накладные расходы. Необходимо, чтобы объект-
итератор создавался в динамической памяти фабричным методом. Поэтому
использовать их стоит только тогда, когда есть необходимость в полимор-
физме. В противном случае применяйте конкретные итераторы, которые
вполне можно распределять в стеке.

К>*p++; // прочесть/записать и перейти дальше
К>*--p; // отступить и прочесть/записать
К>

MOV (R0)+,(R1)+
Или
MOV -(R0),-(R1)

L1: MOV (R0)+, (R1)+
    BNE L1

J>>std::for_each(it1, it2, <всякая фигня>);
J>>

MyCont::iterator it1 = std::find_if(cont.begin(), cont.end(), P1);
MyCont::iterator it2 = std::find_if(it1, cont.end(), P2);
std::for_each(it1, it2, f);

VD>using System;
VD>using System.Collections.Generic;
VD>using System.IO;

VD>class Program
VD>{
VD>    static void Main(string[] args)
VD>    {
VD>        Dictionary<string, int> concordance = new Dictionary<string, int>();
VD>        // Перебираем слова...
VD>        foreach (string word in GetWord(File.ReadAllText(args[0])))
VD>        {
VD>            int count;
VD>            // Пробуем получить значение. Если оно не задано count будет равен 0.
VD>            // что нам и надо.
VD>            concordance.TryGetValue(word, out count);
VD>            concordance[word] = count + 1;
VD>        }

VD>        // Копируем список ключей хэш-таблицы в динамический массив и сортируем его.
VD>        List<string> keys = new List<string>(concordance.Keys);
VD>        keys.Sort();

VD>        // Выводим информацию о каждом слове.
VD>        foreach (string key in keys)
VD>            Console.WriteLine("Слово {0,20} встретилось {1,3} раз[а].",
VD>                key, concordance[key]);
VD>    }

VD>    // Возвращает список слов из мереданного текста.
VD>    static IEnumerable<string> GetWord(string text)
VD>    {
VD>        // Перебираем все символы...
VD>        for (int i = 0; i < text.Length; i++)
VD>        {
VD>            char ch = text[i];

VD>            // Если это начало слова...
VD>            if (char.IsLetter(ch))
VD>            {
VD>                int strat = i;
VD>                // Ищем его конец.
VD>                for (++i; i < text.Length; i++)
VD>                {
VD>                    if (!char.IsLetterOrDigit(ch = text[i]))
VD>                    {
VD>                        // Если конец найден, получаем подстроку и вызвращем его в итераторе.
VD>                        yield return text.Substring(strat, i - strat);
VD>                        break;
VD>                    }
VD>                }
VD>            }
VD>        }
VD>    }
VD>}
VD>

#include <map>
#include <string>
#include <fstream>
#include <iostream>

using namespace std;

int main(int argc, char * argv[])
{
    string str;
    map<string, long> concordance;
    ifstream input(argv[1]);
    
    if (!input.is_open())
        cerr << "Не могу открыть файл" << endl;

    while (input >> str)
        ++concordance[str];

    for (map<string, long>::const_iterator i = concordance.begin(); i != concordance.end(); ++i)
        cout << "Слово " << i->first << " встретилось " << i->second << " раз[а]" << endl;

    return 0;
}

VD>О как!

VD>struct notifier
VD>{
VD>    os::uint32_t m_cseq;
VD>    notifier(os::uint32_t a_cseq) :m_cseq(a_cseq) {}
VD>    void operator()(sip_stack_observer *element)
VD>    {
VD>        element->handle_end_of_dialog(m_cseq);
VD>    }
VD>};
VD>std::for_each(m_agents.begin(),m_agents.end(),notifier(a_cseq));
VD>

VD>for(std::list<sip_stack_observer*>::iterator it=m_agents.begin();iterator!=m_agents.end();it++)
VD>    (*it)->handle_end_of_dialog(a_cseq);
VD>

VD>foreach (Elem elem in m_agents)
VD>    elem.handle_end_of_dialog(a_cseq);
VD>

VD>m_agents.ForEach(delegate(Elem elem) { elem.handle_end_of_dialog(a_cseq); });
VD>

foreach(Elem elem, m_agents)
    elem.handle_end_of_dialog(a_cseq);

V>>(не ты ли неоднократно советовал использовать for вместо foreach по-возможности )

V>>А паттерны — вещь хорошая, разумеется, но им стоило бы быть аккуратнее в именовании тех вещей, в которых не они были первыми. Итератор из GoF они могли бы назвать и подругому, дабы избежать обсуждаемого конфликта одноименных понятий.

VD>Вы? А вы их применяете? По твоим словам в СТЛ же все есть и вам больше не нужно.

> Как раз список с прозвольным доступом это более чем нормально. Видимо из-за передозировки С++.

Грамотное деление было бы следующим:
Итератор — перечисление.
Коллекция — возможность узнанать количество элементов и возможности получения их списка.
Список с произвольным доступом — произвольный доступ к элементам.

J>>MyCont::iterator it1 = std::find_if(cont.begin(), cont.end(), P1);
J>>MyCont::iterator it2 = std::find_if(it1, cont.end(), P2);
J>>std::for_each(it1, it2, f);

CS>  bool found; 
CS>  foreach( element e; MyCont )
CS>  {
CS>    if( !found || P1(e) ) found = true; else continue;
CS>    if( P2(e) ) break; // open-range case

CS>    f(); // your code is here 
CS>  }

J>MyCont::iterator it1 = std::find_if(cont.begin(), cont.end(), P1);
J>MyCont::iterator it2 = std::find_if(it1, cont.end(), P2);
J>std::for_each(it1, it2, f);
J>

/// Выводит ту часть последовательности input, которая не удовлетворяет критерию limit:
public static IEnumerable<T> Limit(IEnumerable<T> input, Predicate<T> limit)
{
  foreach(T t in input) 
        if (limit(t)) return; 
        else yield return t;
}

/// выводит элементы последовательности input начиная с того, который удовлетворяет start.
public static IEnumerable<T> After(IEnumerable<T> input, Predicate<T> start)
{    
  bool found = false;
    foreach(T t in input)
    {
      found |= start(t);
      if(found)
          yield return t;
    }
}
/// Собственно, код задачи.
public static ApplyWithinLimits(IEnumerable input, Action<T> action, Predicate<T> startAt, Predicate<T> stopAt)
{
  foreach(T t in Limit(After(input, startAt), stopAt))
       action(t);
}

*p++; // прочесть/записать и перейти дальше
*--p; // отступить и прочесть/записать

The next() function returns the item that it jumps over.

The diagram below illustrates the effect of calling next() and previous() on an iterator:

"Нельзя войти в одну реку (в один поток) дважды",
(С) Гераклит, 510-512 Anno Domini.

Если человек признает свои ошибки, когда он неправ, – значит, он мудр.
Если человек признает свои ошибки, даже когда он прав, – значит, он
женат.
Народная мудрость

That means I care deeply about how fast things are, and about keeping them small and tight.

Iterators confuse two separate concepts! Separating property access from
object identification clears things up. Of course, everybody is now used
to iterators confusing these two things liberally but this should be
corrected since it causes all kinds of problems. To me the only question
is how the interface is effectively supposed to look like. The question
is not whether iterators and property maps should be separated: That's a
given! For me, at least...
...
here is a list of problems:

— const_iterator vs. iterator:
— can these be compared and/or converted?
— can both be used to specify positions in containers?
— how to get an iterator from a const_iterator?
— value_type
— how to deal with multiple values? map's approach does not scale and
causes eg. problems to key/value organization?
— how to search for key in a sequence of pairs (eg. to implement a
vector based map)?
— how to sort a container with polymorphic object but with a value
like feeling? (the problem is the missing distinction between the
value for the comparison and the holder maintaining the object)
— how to create a proxy container?
— harder to extend:
— creating eg. a filtering iterator requires details on iterator's
member functions
— how to add a derived attribute and use the iterator with find on
the derived attribute?
...

The second problem with the Java collection classes is iterator inconvenience. In C++, iterators were simple. If you have a collection with n elements, there are n + 1 iterator positions: At the first, second, . . ., nth element, and past the nth element. You could think of an iterator as a cursor like the old terminals used to have (and Emacs still has). Alternatively, you can think of the iterator as new-fangled caret--a vertical line that is between elements. Then the n + 1 positions are before the first, between the first and second, . . . between the (n-1)st and nth, and past the nth element. Both interpretations are essentially equivalent, but the "cursor" view makes it a bit easier to interpret the element that the iterator currently visits.

What should happen when you add an element at the iterator position? Both C++ and Java do the right thing--which is the same thing your text editor does. The element is inserted before the iterator, and the iterator moves past the inserted element, like this:

a|bc => ax|bc (after inserting x)

How about deleting the iterator position? C++ does what your text editor would do when you press the Delete key (ok, except on the Mac, don't get me going...). The element under the cursor (or to the right of the caret) is deleted, like this:

ax|bc => ax|c (after deleting)

How about Java? Well, you can't tell. It depends if the iterator had just moved to the right, to the left, or not at all. Huh? In the last case, the remove method even throws an exception! If you want to delete two consecutive elements, then you have to move the iterator past the first one, invoke the remove method, and move the iterator over the adjacent element before calling remove again. If my text editor worked like that, it would drive me crazy.

I don't think I am the only one who is aggrieved by Java iterators. Douglas Dunn has a long-winded section in his splendid book "Java Rules", trying to explain the behavior of iterators. (He takes a different tack, taking the remove functionality for granted and then laboriously tries to explain the inconsistency of the add method.)

     while (i.hasNext())
         cout << i.next().ascii() << endl;

     while (i.hasNext()) {
         if (i.next() % 2 != 0)
             i.remove();
     }

     QMap<int, QWidget *> map;
     QHash<int, QWidget *> hash;

     QMapIterator<int, QWidget *> i(map);
     while (i.hasNext()) {
         i.next();
         hash.insert(i.key(), i.value());
     }

     std::map<int, QWidget*> map;
     std::hash_map<int, QWidget> hash(map.begin(), map.end());

VD> 00427CD0
VD>

00427C6000427C200015536000427C30100427C4C00427C200015536000427C30900427C4C00427C200015536000427C30100427C4C004
27C200015536000427C30100427C4C00427C200015536000427C30100427C4C00427C20001560C800427C30100427C4C00427C20001560
C800427C30100427C4C00427C200015536000427C30300427C4C00427C200015536000427C30200427C4C00427C200015536000427C301
00427C4C00427C200015536000427C30100427C4C00427C200015536000427C30500427C4C00427C20001560C800427C30100427C4C004
27C20001560C800427C30100427C4C00427C200015536000427C30100427C4C00427C200015536000427C30200427C4C00427C20001553
6000427C30100427C4C00427C200015536000427C30200427C4C00427C200015536000427C30100427C4C00427C200015536000427C303
00427C4C00427C20001560C800427C30100427C4C00427C20001560C800427C30100427C4C00427C200015536000427C30200427C4C004
27C200015536000427C30200427C4C00427C200015536000427C30100427C4C00427C200015536000427C30200427C4C00427C20001553
6000427C30200427C4C00427C200015536000427C30200427C4C00427C200015536000427C30200427C4C00427C200015536000427C303
00427C4C00427C200015536000427C30300427C4C00427C200015536000427C30300427C4C00427C200015536000427C30100427C4C004
27C20001560C800427C30200427C4C00427C200015536000427C30100427C4C00427C20001560C800427C30100427C4C00427C20001553
6000427C30100427C4C00427C20001560C800427C30100427C4C00427C200015536000427C30100427C4C00427C200015536000427C301
00427C4C00427C200015536000427C30100427C4C00427C200015536000427C30200427C4C00427C200015536000427C30200427C4C004
27C20001560C800427C30100427C4C00427C20001560C800427C30100427C4C00427C200015536000427C30100427C4C00427C20001553
6000427C30100427C4C00427C200015536000427C30100427C4C00427C200015536000427C30100427C4C00427C20001560C800427C302
00427C4C00427C200015536000427C30100427C4C00427C200015536000427C30200427C4C00427C200015536000427C30100427C4C004
27C200015536000427C30100427C4C00427C200015536000427C30300427C4C00427C200015536000427C30100427C4C00427C20001560
C800427C30100427C4C00427C200015536000427C30100427C4C00427C20001560C800427C30100427C4C00427C200015536000427C301
00427C4C00427C200015536000427C30300427C4C00427C200015536000427C30100427C4C00427C200015536000427C30200427C4C004
27C200015536000427C30100427C4C00427C200015536000427C30100427C4C00427C200015536000427C30100427C4C00427C20001560
C800427C30100427C4C00427C200015536000427C30100427C4C00427C200015536000427C30100427C4C00427C20001560C800427C305
00427C4C00427C200015536000427C30300427C4C00427C200015536000427C30300427C4C00427C200015536000427C30100427C4C004
27C200015536000427C30600427C4C00427C20001560C800427C30100427C4C00427C200015536000427C30100427C4C00427C20001553
6000427C30100427C4C00427C200015536000427C30100427C4C00427C200015536000427C30100427C4C00427C20001560C800427C301
00427C4C00427C200015536000427C30100427C4C00427C200015536000427C30100427C4C00427C200015536000427C30300427C4C004
27C20001560C800427C30100427C4C00427C200015536000427C30200427C4C00427C200015536000427C30100427C4C00427C20001553
6000427C30100427C4C00427C20001560C800427C30100427C4C00427C20001560C800427C30100427C4C00427C200015536000427C304
00427C4C00427C200015536000427C30100427C4C00427C200015536000427C30400427C4C00427C200015536000427C30100427C4C004
27C20001560C800427C30100427C4C00427C200015536000427C30200427C4C00427C200015536000427C30100427C4C00427C20001553
6000427C30100427C4C00427C200015536000427C30300427C4C00427C200015536000427C30100427C4C00427C20001560C800427C301
00427C4C00427C200015536000427C30100427C4C00427C200015536000427C301000427C4C00427BE4Press any key to continue .
. .

// StringTest.cpp : Defines the entry point for the console application.
//

#include <iostream>
#include <tchar.h>
#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS    // some CString constructors will be explicit

#include <atlbase.h>
#include <atlfile.h>
#include <atlstr.h>
#include <atlcoll.h>


int _tmain(int argc, _TCHAR* argv[])
{
    typedef char XCHAR;        // define which format do we work with: ansi/mbcs or unicode
    typedef ChTraitsCRT<XCHAR> ChTraitsX;    // define char traits for strings (will use it also seperately)
    typedef CStringT< XCHAR, StrTraitATL<XCHAR, ChTraitsX> > CStringX;    // our strings;
    typedef CAtlMap<CStringX, size_t> str_map;        // string map ( uses hash capability of atl strings )

    CAtlFile file;    // atl wrapper for files
    CAtlFileMapping<XCHAR> mapping;    // atl wrapper for memory-mapped files. Allows access to files up to 2 GB length as memory area.
    if(argc < 2
        || FAILED(file.Create(argv[1], GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING))
        || FAILED(mapping.MapFile(file))
        )
    {
        std::cout << _T("error opening file");
        return 0;
    }

    static CStringX space_mask(" \t\r\n,./?;:\"'!()-+*=\\|{}<>[]");    // mask with seperator symbols
    
    str_map words;    // map object
    
    for(const XCHAR *it = mapping, *it_end = (const XCHAR*)mapping + mapping.GetMappingSize();
        it < it_end; 
        it = ChTraitsX::CharNext(it))    // function needed to operate with mbcs symbols correctly
    {
        const XCHAR* it_prev = it;
        while(it_prev != it_end && 0 <= space_mask.Find(*it_prev))    // skip seperator symbols at the beginning
            it_prev = ChTraitsX::CharNext(it_prev);
        it = it_prev;
        while(it != it_end && space_mask.Find(*it) < 0)    // find seperator
            it = ChTraitsX::CharNext(it);
        if(it != it_prev)
        {
            CStringX word(it_prev, it - it_prev);        // extract the word
            str_map::CPair* pPair = words.Lookup(word);    // lookup if the word is allready in the map
            if(pPair)
                ++pPair->m_value;    // if yes, increase counter
            else
                words[word] = 1;    // if no, reset counter to 1
        }
    }
    std::cout << _T("======Begin dump=======\r\n");
    for(POSITION pos = words.GetStartPosition(); pos; )    // enumerate pairs in the map and dump them to cout
    {
        str_map::CPair* pPair = words.GetNext(pos);
        std::cout << _T("word \"") << CString(pPair->m_key) << _T("\" accured ") << pPair->m_value << _T("times\r\n");
    }
    std::cout << _T("======End dump=======\r\n");
    return 0;
}

sort(container);

sort(range(container, 10, 20));

You won't get argument from me here. While I don't mean to say there are
not many very useful classes in BOOST, the sheer amount of dirt you have
to pull in, just to use it, is making BOOST less and less of a library I
would consider for doing anything.

It is IMO becoming a display of the failure of compilers and language
extensions, on the other extreme but in its practical nonsense
complementary to latest MS additions to 'managed C++'.

ПК>templ_function( **it );

templ_function(undress(*it)); // раздевает ссылку
templ_function(*undress(it)); // раздевает указатель
templ_function((*it).get());
templ_function(*(it.get()));

public class MyArrayBasedCollection
{
  public IEnumerable SubRange(int start, int end)
    {
      for(int i = start, i<end; i++)
          yield return this[i];
    }
}

...
foreach (object o in myabc.SubRange(1, 50))
{
  Console.Write(o);
}

...

public static IEnumerable<T> Limit(IEnumerable<T> source, int limit)
{
  int i;
    foreach(T t in source)
    {
      if (i++ > limit) return;
        yield return t;
    }
}
...
int[] a = new int[50];
foreach(object o in Limit(a, 5));

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

static IEnumerable<T> Sort2<T>(IEnumerable<T> enumerable)
    where T : IComparable<T>
{
    // Пытаемся получить медиану для дальнейшего стравнения.
    // Так как произвольного доступа к элементам нет, то приходится
    // брать первый элемент. Это приведет к плохой производительности
    // на отсортированных массивах.
    IEnumerator<T> iterator = enumerable.GetEnumerator();

    // Если список пуст, то и делать нечего.
    if (!iterator.MoveNext())
        yield break;

    T median = iterator.Current; // получили элемент для сравнения

    // Фильтруем список отбирая элементы меньшие median-а.
    // Для получившегося списка выполняем сортировку (рекурсивно).
    // Перебераем получившися (отсортированный) подсписок и возвращаем
    // его элементы.
    foreach (T value in Sort1(Filter(enumerable, 
        delegate(T item) { return item.CompareTo(median) < 0; })))
        yield return value; 

    // Делам тоже самое но отфильтровываем элеметы большие или равные медиане.
    foreach (T value in Sort1(Filter(enumerable,
        delegate(T item) { return item.CompareTo(median) >= 0; })))
        yield return value;
}

// Эта функция создает список в который попадают элементы удовлетворяющие предикату.
// Попросту говоря она отфильтровывает все элементы для которых predicate() вовращает true.
static IEnumerable<T> Filter<T>(IEnumerable<T> enumerable, Predicate<T> predicate)
{
    foreach (T value in enumerable)
        if (predicate(value))
            yield return value;
}

//#define USE_ITERATIR_SORT

using System;
using System.Collections.Generic;

class Program
{
    const int SecLen = 1000000;

    static void Main(string[] args)
    {
        List<int> result = new List<int>(SecLen);

        int start = Environment.TickCount;

#if USE_ITERATIR_SORT
        foreach (int i in Sort1(Generator()))
            result.Add(i);
#else
        result.AddRange(Generator());
        result.Sort();
#endif

        Console.WriteLine("Time is " + (Environment.TickCount - start));

        int sum = 0;
        result.ForEach(delegate(int elem) { sum += elem; });
        Console.WriteLine(sum);
    }
    
    // Генерирует последовательность случайных числе.
    // Возвращает итератор который используется для тестов.
    static IEnumerable<int> Generator()
    {
        Random random = new Random(123456);

        for (int i = 0; i < SecLen; i++)
            yield return random.Next();
    }

    static IEnumerable<T> Sort1<T>(IEnumerable<T> enumerable)
        where T : IComparable<T>
    {
        IEnumerator<T> iterator = enumerable.GetEnumerator();

        if (!iterator.MoveNext())
            yield break;

        T median = iterator.Current;

        List<T> left = new List<T>();
        List<T> right = new List<T>();

        while (iterator.MoveNext())
        {
            T value = iterator.Current;

            if (value.CompareTo(median) < 0)
                left.Add(value);
            else
                right.Add(value);
        }

        foreach (T value in Sort1(left))
            yield return value;

        yield return median;

        foreach (T value in Sort1(right))
            yield return value;
    }

    static IEnumerable<T> Sort2<T>(IEnumerable<T> enumerable)
        where T : IComparable<T>
    {
        IEnumerator<T> iterator = enumerable.GetEnumerator();

        if (!iterator.MoveNext())
            yield break;

        T median = iterator.Current;

        foreach (T value in Sort1(Filter(enumerable, 
            delegate(T item) { return item.CompareTo(median) < 0; })))
            yield return value;

        foreach (T value in Sort1(Filter(enumerable,
            delegate(T item) { return item.CompareTo(median) >= 0; })))
            yield return value;
    }

    static IEnumerable<T> Filter<T>(IEnumerable<T> enumerable, Predicate<T> predicate)
    {
        foreach (T value in enumerable)
            if (predicate(value))
                yield return value;
    }
}

Time is 4812
-14996129

Time is 4907
-14996129

Time is 187
-14996129

The Java-style iterators are new in Qt 4.0 and are the standard ones used in Qt applications. They are more convenient to use than the STL-style iterators, at the price of being slightly less efficient. Their API is modelled on Java's iterator classes.

some_generator g(some_begin, some_end);
some_accessor a;
...
while(!g.eof())
{
  a = g.peek(); // не меняет состояние генератора
  a.put(some_value()); // я сознательно не пишу здесь операторы, чтобы не проводить лишних аналогий

  a = g.read(); // меняет состояние генератора - тот уезжает вперёд, оставляя за собой Accessor
  some_data d = a.get();
  ...
  some_generator h(some_begin, a); // новый генератор: от начала до этого элемента исключительно
  ...
}

      o
 ____/ \____
o           o
 \         /
 ...     ...
   \     /
    X   Y

> *p++; // прочесть/записать и перейти дальше
> *--p; // отступить и прочесть/записать
>

*it = create_expensive_object();

       template<class _FwdIt, class _Pr> inline
    _FwdIt remove_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
    {    // remove each satisfying _Pred
    _First = std::find_if(_First, _Last, _Pred);
    if (_First == _Last)
        return (_First);    // empty sequence, all done
    else
        {    // nonempty sequence, worth doing
        _FwdIt _First1 = _First;
        return std::remove_copy_if(++_First1, _Last, _First, _Pred);
        }
    }

Map::iterator pos = m.lower_bound(key);       // ищем элемент
if ( pos == m.end() || pos->first != key )
{
   // такого элемента еще нет, добавляем
   m.insert(pos, Map::value_type(key, value)); // поиска здесь уже не будет
}
else
{
   // OK, такой элемент уже есть, делаем, что нужно для этого случая
   // например, изменяем его как-нибудь
   modify_existing_value(it->second, key, value);
}

V>>Именно глупость, или невнимательное чтение оппонента. Задача описания паттерна — это тоже задача. GoF поставили задачу донести суть повторно применимых приемов до IT-сообщества. Похоже, перестарались с лаконичностью. Кое-кто воспринял слишком буквально. Им стоило разбавить свою книжку примерами и реализациями паттернов с учетом различных специфик, тогда этой ветки могло и не быть.

l Implementation Issues:

= Who controls the iteration?
— The client => more flexible; called an external iterator
— The iterator itself => called an internal iterator

= Who defines the traversal algorithm?
— The iterator => more common; easier to have variant traversal techniques
— The aggregate => iterator only keeps state of the iteration

= Can the aggregate be modified while a traversal is ongoing? An iterator
that allows insertion and deletions without affecting the traversal and
without making a copy of the aggregate is called a robust iterator.

= Should we enhance the Iterator interface with additional operations, such as
previous()?

V>>Попробуй по-другому.

VD>Зачем мне пробовать? Я делвают.

template<class RandomAccessIterator>
void sort(RandomAccessIterator first, RandomAccessIterator last);

template<class T>
void sort(T* first, T* last);

std::for_each(it1, it2, <всякая фигня>);

ПК>templ_function( get(*it) );

ПК>templ_function( static_cast<T&>(*it) );