iterator Specialized Adaptors

counting_iterator
Şöyle yaparız.

int N = 7;
std::vector<int> numbers;
...
std::vector<std::vector<int>::iterator> pointers;
std::copy(boost::make_counting_iterator(numbers.begin()),
          boost::make_counting_iterator(numbers.end()),
          std::back_inserter(pointers));

filter_iterator
Örnek ver
function_input_iterator
Örnek ver
function_output_iterator
Örnek ver
indirect_iterator
Örnek ver
permutation_iterator
Örnek ver
reverse_iterator
Örnek ver
shared_container_iterator
Örnek ver

transform_iterator
Örnek
Elimizde şöyle bir sınıf olsun ve bu sınıftan bir vector olsun.

class A
{
public:
  const B& GetB() const;
};

vector<A> manyA;

Tüm vector nesnesini dolaşarak B nesnelerine şöyle erişiriz.

typedef boost::transform_iterator<boost::function<B&(A&)>, 
                                  vector<A>::iterator> BIter;

BIter beginBIter(manyA.begin(), boost::mem_fn(&Layer::GetB));
BIter endBIter(manyA.end(), boost::mem_fn(&Layer::GetB));

Örnek

Elimizde int iterator alan bir algoritma olsun.

template <typename It>
void doWork(It begin, It end) {
  int x = *begin; // range is over integers
  // ...
}

int yerine struct ile de çalışsın isteyelim.

struct S { int x; }
using SList = std::vector<S>;

Bu durumda transform_iterator, struct'ı int'e çevirmek için kullanılabilir.

zip_iterator
Şu satırı dahil ederiz.

#include <boost/iterator/zip_iterator.hpp>

Tüm iterator'lerin uzunlukları aynı olmalı. Eğer farklı uzunluktaysalar en kısası kadar dolaşmak gerekir.
Örnek
zip_iterator yaratmak için şöyle yaparız.

boost::make_zip_iterator(boost::make_tuple(end1, end2))

Örnek
Sınıfım içinde şu tanımlamaları yaparız.

std::vector<int> a{11, 21, 41};
std::vector<int> b{1, 2, 4};
typedef boost::zip_iterator<boost::tuple<std::vector<int>::const_iterator,
  std::vector<int>::const_iterator>> myconst_iterator;
typedef boost::zip_iterator<boost::tuple<std::vector<int>::iterator,
  std::vector<int>::iterator>> myiterator;

Bu iteator'leri dönmek için şöyle yaparız.

myconst_iterator begin() const {
  return myconst_iterator(boost::make_tuple(a.cbegin(), b.cbegin()));
}
myconst_iterator end() const {
  return myconst_iterator(boost::make_tuple(a.cend(), b.cend()));
}
myiterator begin() {
  return myiterator(boost::make_tuple(a.begin(), b.begin()));
}
myiterator end() {
  return myiterator(boost::make_tuple(a.end(), b.end()));
}

Bu sınıfı dolaşmak için şöyle yaparız.

Foo foo;
for (auto &ab: foo)
  ab.get<0>() = 66;