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.

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

// параметризуемый класс (ака template)
class Collection(T)
{
  int opApply(int delegate(inout T) dg) 
  {
      для всех элементов коллекции вызвать dg...
  }
}

Collection!(Foo) myFooCollection;

foreach( Foo f; myFooCollection ) // foreach это просто вызов метода opApply 
{                                 // c синтезированным "naked" delegate
   f.something() ...
}

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

std::sort(container.begin(), container.begin() + 10);

// вот как выглядят некоторые алогритмы
template<class InputScanner, class OutputScanner>
void copy_javalike(InputScanner src, OutputScanner dst)
{
  while(!src.finish()) dst.write(src.read());
}
template<class InputScanner, class OutputScanner, class Transform>
void transform_javalike(InputScanner src, OutputScanner dst, Transform tf)
{
  while(!src.finish()) dst.write(tf(src.read());
}
template<class InputScanner, class Value, class SumFunc>
Value adjacent_sum_javalike(Value start, InputScanner src, SumFunc sum)
{
  while(!src.finish()) start = sum(start,src.read());
  return start;
}

// переходники от указателей к сканерам

template<class InputIterator>
struct stl_input_scanner
{
  InputIterator begin, end; // дань традиции STL: конец диапазона задаётся указателем на "за-конец"
  stl_input_scanner(InputIterator b, InputIterator e) : begin(b), end(e) {}
  bool finish() const { return begin==end; }
  typename std::iterator_traits<InputIterator>::value_type read() { return *begin++; }
};

template<class OutputIterator>
struct stl_output_scanner
{
  OutputIterator pos;
  stl_output_scanner(OutputIterator p) : pos(p) {}
  template<class Value>
  void write(Value const& v) { *p++ = v; }
};

ЗХ>Ты знаешь, Макс, в последнее время я тоже стал приходить к этой мысли

struct my_output_iterator : iterator<input_iterator_tag, Value>
{
  my_output_iterator& operator++(int) { return *this; } // тяп-ляп номер раз
  my_output_iterator& operator*() { return *this; } // тяп-ляп номер два
  my_output_iterator& operator=(Value v) { NowWriteIt(v); }
};

// делаем оснастку для SomeInputFile
struct access_to_SomeFile
{
  typedef Data value_type;
  typedef SomeFile file_type;
  static bool eof(file_type& f) { return f.EndOfFile(); }
  static Data read(file_type& f) { Data v; f.Read(v); return v; }
};

// строим правильный стопроцентно совместимый и грамотно бьющий по пальцам итератор в духе святого STL
typedef file_input_iterator< access_to_SomeFile > somefile_input_iterator;

ЗХ>>Ты знаешь, Макс, в последнее время я тоже стал приходить к этой мысли

Прошлым летом поимел опыт экстремального программирования. Ездил в коммандировку. В шахте на глубине 800 метров в каске с фонарём на ноутбуке правил прогу на ассме.

class cursor
{
...
    bool    next();
    value_t    get();
...
}

ЗХ>class cursor
ЗХ>{
ЗХ>...
ЗХ>    bool    next();
ЗХ>    value_t    get();
ЗХ>...
ЗХ>}

ЗХ>и мне от него больше ничего не нада. Причем через .end(), ++, == это выражалось сууущественно хуже.