iterator

Giriş
Açıklaması şöyle

The iterator categories defined in C++98 are extremely limiting because they bind together two orthogonal concepts: traversal and element access. For example, because a random access iterator is required to return a reference (and not a proxy) when dereferenced, it is impossible to capture the capabilities of vector<bool>::iterator using the C++98 categories

Iterator Facade and Adaptor
iterator_facade
iterator_facade yazısına taşıdım.

iterator_adaptor
Şöyle yaparız.

#include <boost/iterator_adaptors.hpp>

template <typename BaseIterator>
struct Adapt : boost::iterator_adaptor<Adapt<BaseIterator>, BaseIterator> {
  using base = boost::iterator_adaptor<Adapt<BaseIterator>, BaseIterator>;
  using base::base;
  using base::operator=;
};

Specialized Adaptors
iterator Specialized Adaptors yazısına taşıdım.

Yardımcı Sınıflar
make_transform_iterator
transform_iterator yaratmayı kolaylaştırır. Şöyle yaparız.

typedef std::map<std::string, int>::value_type value_type;
std::map<std::string, int> a;
a["one"] = 1;
a["two"] = 2;

// returns the second element 
boost::function<int(value_type&)> f = boost::bind(&value_type::second, _1);
std::copy(boost::make_transform_iterator(a.begin(), f), 
          boost::make_transform_iterator(a.end(), f),
          std::ostream_iterator<int>(std::cout, " "));

Çıktı olarak 1 ve 2 alırız.

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;