 |
Общее понятие об итераторе
|
|
|
|
Для структурированных итераций, например, при обработке массивов:
for(i=0;i<size;i++) sm+=a[i];
порядок обращения к элементу управляется индексом i, который изменяется явно. Можно зафиксировать получение следующего элемента в компоненте-функции.
Class vect
{ int *p; // массив чисел
int size; // размерность массива
int ind; // текущий индекс
public:
vect(); // размерность массива const
vect(int SIZE); // размерность массива size
~vect();
int ub(){return size-1;}
int next()
{ if(ind==pv->size)
return pv->p[(ind=0)++];
else
return pv->p[ind++];
}
};
Это соответствует тому, что обращение к объекту ограничивается использованием одного индекса ind. Другая возможность состоит в том, чтобы создать множество индексов и передавать функции обращения к элементу один из них. Это ведет к существенному увеличению числа переменных. Более удобным представляется создание отдельного, связанного с vect класса (класса итераций), в функции которого входит обращение к элементам класса vect. В приведенном ниже примере, для универсальности разрабатываемого класса vect использованы шаблоны классов vect и vect_iterator.
#include <iostream.h>
template<class T> // предварительное template объявление
class vect_iterator; // класса vect_iterator
template<class T>
class vect // шаблон класса vect
{ friend class vect_iterator<T>; // предварительное friend-объявление
T *p; // базовый указатель (массив)
int size; // размерность массива
public:
vect(int SIZE):size(SIZE)
{ p=new T[size];
for(int i=0; i<size; *(p+i++)=(T)i);
}
int ub(){return size-1;} // возвращается размер массива
void add() // изменение содержимого массива
{ for(int i=0; i<size; *(p+i++)+=1);}
~vect(){delete [] p;}
};
template<class T>
Class vect_iterator
{ vect<T> *pv; // указатель на класс vect
int ind; // текущий индекс в массиве
public:
vect_iterator(vect<T> &v): ind(0),pv(&v){}
T &next();//возвращается текущее значение из массива (с индекса ind)
|
|
|
};
template<class T> // шаблон класса vect_iterator
T &vect_iterator<T>::next()
{ if(ind==pv->size)
return (T)pv->p[(ind=0)++];
else
return (T)pv->p[ind++];
}
void main()
{ vect<int> v(5);
vect_iterator<int> v_i1(v),v_i2(v); // создано 2 объекта-итератора
// для прохода по объекту vect
cout<<v_i1.next()<<' '<<v_i2.next()<<endl;
v.add(); // модификация объекта v
cout<<v_i1.next()<<' '<<v_i2.next()<<endl;
for(int i=0;i<v.ub();i++)
cout<<v_i1.next()<<endl;
}
Результат работы программы:
0 0
2 2
Полное отсоединение обращения от составного объекта позволяет объявлять столько объектов итераторов, сколько необходимо. При этом каждый из объектов итераторов может просматривать объект vect независимо от других.
Итератор представляет собой операцию, обеспечивающую последовательный доступ ко всем частям объекта. Итераторы имеют свойства, похожие на свойства указателей, и могут быть использованы для указания на элементы контейнеров первого класса. Итераторы реализуются для каждого типа контейнера. Также имеется целый ряд операций (*, ++ и другие) с итераторами, стандартными для контейнеров.
Если итератор a указывает на некоторый элемент, то ++a указывает на следующий элемент, а *a ссылается на элемент, на который указывает a.
Объект типа iterator может использоваться для ссылки на элемент контейнера, который может быть модифицирован, а const_iterator для ссылки на немодифицируемый элемент контейнера.
Еще один пример реализации контейнерного класса vect. В этом случае итерационный механизм реализован в непосредственно в классе vect.
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
template <class T>
class vect // шаблон класса vect
{ int size; // размерность массива
public:
typedef T* vect_iterator;
typedef const T* const_vect_iterator;
vect_iterator vv; // итератор контейнера
const_vect_iterator cv; // константный итератор
vect()
{ vv=new T; //
cv=vv; //
size=0;
}
~vect(){}
vect_iterator begin_v(); // итератор на начало вектора
vect_iterator end_v(); // итератор на конец вектора
void push_b(T); // добавление элемента в конец вектора
|
|
|
void pop_b(); // удаление элемента с конца вектора
void insert_v(T,T*); // добавление элемента в вектор
void erase_v(T*); // удаление элемента с конца вектора
};
template <class T>
void vect<T>::push_b(T a)
{ vect_iterator temp;
temp=new T[++size];
for(int i=0;i<size-1;i++)
*(temp+i)=*(vv+i);
*(temp+size-1)=a;
delete vv;
vv=temp;
}
template <class T>
T* vect<T>::begin_v()
{ return vv; }
template <class T>
T* vect<T>::end_v()
{ return vv+size; }
template <class T>
void vect<T>::pop_b()
{ vect_iterator temp;
temp=new T[--size];
for(int i=0;i<size;i++)
*(temp+i)=*(vv+i);
delete vv;
vv=temp;
}
template <class T>
void vect<T>::insert_v(T zn,T* adr)
{ int k=0;
vect_iterator temp;
temp=new T[++size];
for(vect_iterator i=vv;i<adr;i++)
*(temp+k++)=*i;
*(temp+k)=zn;
for(i=adr;i<vv+size-1;i++)
*(temp+ ++k)=*i;
delete vv;
vv=temp;
}
template <class T>
void vect<T>::erase_v(T* adr) // adr - итератор на удаляемый
{ int k=0; // элемент контейнера
vect_iterator temp;
temp=new T[--size]; // временный вектор
for(vect_iterator i=vv;i<adr;i++)
*(temp+k++)=*i;
for(i=adr+1;i<=vv+size;i++)
*(temp+k++)=*i;
delete vv; // освобождение памяти для старого вектора
vv=temp; // vv указывает нп новый вектор
}
void menu(void)
{ cout<<endl;
cout<<"1 - добавить элемент"<<endl;
cout<<"2 - pop последний элемент"<<endl;
cout<<"3 - erase элемент"<<endl;
cout<<"4 - print содержимое контейнера"<<endl;
cout<<"0 - окончание работы "<<endl;
}
main()
{ int count;
int choice;
int pos;
int val;
vect<int> Vect; // объект контейнер
vect<int>::vect_iterator itr; // итератор
int a;
cout<<"Сколько элементов вводится в вектор?"<<endl;
cin>>count;
for(int i = 0;i < count; i++)
{ cout<<"enter the element number "<<i+1<<endl;
cin>>a; // инициализация контейнера
Vect.push_b(a); // начальными значениями
}
while(1)
{ menu();
cout<<"? ";
cin>>choice;
cout<<endl;
switch(choice)
{ case 1:
cout<<"Введите значение и позицию "<<endl;
cin>>val>>pos;
Vect.insert_v(val,Vect.begin_v()+pos-1);
cout<<endl;
break;
case 2:Vect.pop_b();
cout<<"Элемент удален";
break;
case 3:
cout<<"Введите позицию элемента для удаления "<<endl;
cin>>pos;
Vect.erase_v(Vect.begin_v()+pos-1);
break;
case 4:
for(itr=Vect.begin_v();itr!=Vect.end_v();itr++)
cout<<*itr<<" ";
break;
case 0: return 0;
}
}
return 0;
}
Категории итераторов
Итераторы, как и контейнеры, реализуются в виде шаблонов классов. Итераторы обладают такими достоинствами, как, например, автоматическое отслеживание размера типа, на который указывает итератор, автоматизированные операции инкремента и декремента для перехода от элемента к элементу. Именно благодаря таким возможностям итераторы и являются фундаментом всей библиотеки.
|
|
|
Итераторы можно условно разделить на две категории: основные и вспомогательные.
Основные итераторы
Основные итераторы используются наиболее часто. Они взаимозаменяемы, однако при этом нужно соблюдать иерархию старшинства (рис.8).
Рис. 8. Иерархия итераторов
Итераторы ввода. Итераторы ввода (input iterator) стоят в самом низу иерархии итераторов. Это наиболее простые из всех итераторов STL, и доступны они только для чтения. Итератор ввода может быть сравнен с другими итераторами на предмет равенства или неравенства, чтобы узнать, не указывают ли два разных итератора на один и тот же объект. Можно использовать оператор разыменовывания (*) для получения содержимого объекта, на который итератор указывает. Перемещаться от первого элемента, на который указывает итератор ввода, к следующему элементу можно с помощью оператора инкремента (++). Ниже приведен пример, демонстрирующий некоторые приемы работы с итератором ввода.
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
main(void)
{ int init1[4];
vector<int> v(4);
istream_iterator<int> ii(cin);
for(int j,i=0;i<4;i++)
// v.push_back(*ii++); добавление в конец вектора
// *(v.begin()+i)=*ii++;
// v[i]=*ii++;
copy(v.begin(), v.end(), ostream_iterator<int>(cout, "\n"));
}
Итераторы ввода возвращает только шаблонный класс istream_iterator. Однако, несмотря на то что итераторы ввода возвращаются единственным классом, ссылки на него присутствуют повсеместно. Это связано с тем, что вместо итератора ввода может подставляться любой из основных итераторов, за исключением итератора вывода, назначение которого прямо противоположно итератору ввода.
template <class InputIterator, class Function>
Function for_each (InputIterator first, InputIterator last, Function f)
{
while (first!= last) f(*first++);
return f;
}
В примере первые два параметра - итераторы ввода на начало цепочки объектов и на первое значение, находящееся "за пределом" для этой цепочки. Тело алгоритма выполняет переход от объекта к объекту, вызывая для каждого значения, на которое указывает итератор ввода first, функцию. Указатель на нее передается в третьем параметре. Здесь задействованы все три перегруженных оператора, допустимые для итераторов ввода: сравнения (!=), инкремента (++) и разыменовывания (*). Ниже приводится пример использования алгоритма for_each для однонаправленных итераторов.
|
|
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void Print(int n)
{ cout << n << " "; }
void main()
{ const int SIZE = 5;
typedef vector<int > IntVector; // создание синонима для vector<int>
typedef IntVector::iterator IntVectorItr;//аналогично для IntVector::iterator
IntVector Numbers(SIZE); //вектор, содержащий целые числа
IntVectorItr start, end; // итераторы для IntVector
int i;
for (i = 0; i < SIZE; i++) // инициализация вектора
Numbers[i] = i + 1;
start = Numbers.begin(); // итератор на начало вектора
end = Numbers.end(); // итератор на запредельный элемент вектора
for_each(start, end, Print);
cout << "\n\n";
}
Чтобы включить в программу возможность использования потоков, добавляется включаемый файл iostream, а для описания прототипа алгоритма for_each в программу включается заголовочный файл algorithm (algorith для продуктов Borland). Обязательным при использовании STL является использование директивы:
using namespace std,
включающей пространство имен библиотеки STL.
Итераторы вывода. Если итератор ввода предназначен для чтения данных, то итератор вывода (output iterator) служит для ссылки на область памяти, куда выводятся данные. Итераторы вывода можно встретить повсюду, где происходит хоть какая-то обработка информации средствами STL. Для данного итератора определены операторы присвоения (=), разыменовывания (*) и инкремента (++). Однако следует помнить, что первые два оператора предполагают, что итератор вывода располагается в левой части выражений, то есть во время присвоения он должен быть целевым итератором, которому присваиваются значения. Разыменовывание нужно делать лишь для того, чтобы присвоить некое значение объекту, на который итератор ссылается. Итераторы вывода могут быть возвращены итераторами потоков вывода (ostream_iterator) и итераторами вставки inserter, front_inserter и back_inserter (рассмотрены ниже в разделе "Итераторы вставки"). Рассмотрим пример использования итераторов вывода:
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
main(void)
{ int init1[] = {1, 2, 3, 4, 5};
int init2[] = {6, 7, 8, 9, 10};
vector<int> v(10);
merge(init1, init1 + 5, init2, init2 + 5, v.begin());
copy(v.begin(), v.end(), ostream_iterator<int>(cout, "\n"));
}
В примере помимо потоков и алгоритмов использован контейнер vector (представляющий одномерный массив, вектор). У него имеются специальные компоненты-функции begin() и end(). В приведенном нами примере создаются и инициализируются два массива - init1 и init2. Далее их значения соединяются вместе алгоритмом merge и записываются в вектор. А для проверки полученного результата мы пересылаем данные из вектора в поток вывода, для чего вызываем алгоритм копирования copy и специальный итератор потока вывода ostream_iterator. Он перешлет данные в поток cout, разделив каждое пересылаемое значение символом окончания строки. Для шаблонного класса ostream_iterator требуется указать тип выводимых значений. В нашем случае это int.
|
|
|
Если в примере описать еще один вектор vv:
vector<int> vv(10);
то в алгоритме copy вместо выходного итератора можно, например, использовать итератор вектора vv для копирования данных из одного вектора в другой:
copy(v.begin(), v.end(), vv.begin());
Рассмотрим еще один пример использования итераторов ввода-вывода.
#include <iostream>
using namespace std;
#include <iterator>
#define N 2
void main()
{ cout<<"Введите "<<N<<" числа"<<endl;
std::istream_iterator<int> in_obj(cin);
int ms[N],i;
for(i=0;i<N;i++)
{ ms[i]=*in_obj; // аналогично ms[i]=*(in_obj++);
++in_obj;
}
ostream_iterator<int> out_obj(cout);
for(i=0;i<N;i++)
*out_obj=ms[i];
cout<<endl;
}
В инструкциях:
std::istream_iterator<int> in_obj(cin);
и
ostream_iterator<int> out_obj(cout);
создаются итераторы istream_iterator и ostream_iterator для ввода и вывода int значений из объектов cin и cout соответственно.
Использование операции * (разыменовывания) ms[i]=*in_obj приводит к получению значения из потока in_obj и занесению его в элемент массива, а в инструкции *out_obj=ms[i] к получению ссылки на объект out_obj ассоциируемый с выходным потоком, и посылке значения элемента массива в поток. Перегруженная операция ++in_obj перемещает итератор in_obj к следующему элементу во входном потоке. Отметим, что для выходного потока операции разыменование и инкремент возвращают одно значение – ссылку на поток.
ostream_iterator<_U, _E, _Tr>& operator*()
{return (*this); }
ostream_iterator<_U, _E, _Tr>& operator++()
{return (*this); }
Однонаправленные итераторы. Если соединить итераторы ввода и вывода, то получится однонаправленный итератор (forward iterator), который может перемещаться по цепочке объектов в одном направлении, за что и получил такое название. Для такого перемещения в итераторе определена операция инкремента (++). Кроме этого, в однонаправленном итераторе есть операторы сравнения (== и!=), присвоения (=) и разыменовывания (*). Все эти операторы можно увидеть, если посмотреть, как реализован, например, алгоритм replace, заменяющий одно определенное значение на другое:
template <class ForwardIterator, class T>
void replace (ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value)
{ while (first!= last)
{ if (*first == old_value) *first = new_value;
++first;
}
}
Чтобы убедиться в правильности работы всех операторов однонаправленных итераторов, составим программу, заменяющую в исходном массиве все единицы на нули и наоборот, т. е. произведем инверсию. С этой целью все нули заменяются на некоторое значение, например на двойку. Затем все единицы обнуляются, а все двойки становятся единицами:
#include <algorithm>
#include <iostream>
using namespace std;
main(void)
{
replace(init, init + 5, 0, 2);
replace(init, init + 5, 1, 0);
replace(init, init + 5, 2, 1);
copy(init, init + 5, ostream_iterator<int>(cout, "\n"));
}
Алгоритм replace, используя однонаправленные итераторы, читает значения, заменяет их и перемещается от одного к другому.
Двунаправленные итераторы. Двунаправленный итератор (bidirectional iterator) аналогичен однонаправленному итератору. В отличие от последнего двунаправленный итератор может перемещаться не только из начала в конец цепочки объектов, но и наоборот. Это становится возможным благодаря наличию оператора декремента (--). На двунаправленных итераторах базируются различные алгоритмы, выполняющие реверсивные операции, например reverse. Этот алгоритм меняет местами все объекты в цепочке, на которую ссылаются переданные ему итераторы. Следующий пример был бы невозможен без двунаправленных итераторов:
#include <algorithm>
#include <iostream>
using namespace std;
main(void)
{
int init[] = {1, 2, 3, 4, 5};
reverse(init, init + 5);
copy(init, init + 5, ostream_iterator<int>(cout, "\n"));
}
Итераторы двунаправленного доступа возвращаются несколькими контейнерами STL: list, set, multiset, map и multimap.
Итераторы произвольного доступа. Итераторы этой категории - наиболее универсальные из основных итераторов. Они не только реализуют все функции, свойственные итераторам более низкого уровня, но и обладают большими возможностями. Глядя на исходные тексты, в которых используются итераторы произвольного доступа, можно подумать, что имеешь дело с арифметикой указателей языка C++. Реализованы такие операции, как сокращенное сложение и вычитание (+= и -=), сравнение итераторов (<, >, <= и >=), операция обращения к заданному элементу массива ([]), а также и некоторые другие операции.
Как правило, все сложные алгоритмы, требующие расширенных вычислений, оперируют итераторами произвольного доступа. Ниже приводится пример, в котором мы используем практически все операции, допустимые для них. Исходный текст разбит на части, к каждой из которых приведены комментарии. Сначала нужно включить требуемые заголовочные файлы и определить константу пробела:
#include <algorithm>
#include <iostream>
#include <vector>
#define space " "
Затем следует включить использование STL:
using namespace std;
В функции main мы описываем массив числовых констант и вектор из пяти элементов:
int main(void)
{
const int init[] = {1, 2, 3, 4, 5};
vector<int> v(5);
Создаем переменную типа "итератор произвольного доступа". Для этого берем итератор и на его основе создаем другой, более удобный:
typedef vector<int>::iterator vectItr;
vectItr itr;
Инициализируем вектор значениями из массива констант и присваиваем адрес его первого элемента итератору произвольного доступа:
copy(init, init + 5, itr = v.begin());
Далее, используя различные операции над итераторами, последовательно читаем элементы вектора, начиная с конца, и выводим их на экран:
cout << *(itr + 4) << endl;
cout << *(itr += 3) << endl;
cout << *(itr -= 1) << endl;
cout << *(itr = itr - 1) << endl;
cout << *(--itr) << endl;
После этого итератор, претерпев несколько изменений, снова указывает на первый элемент вектора. А чтобы убедиться, что значения в векторе не были повреждены, и проверить оператор доступа ([]), выведем в цикле значения вектора на экран:
for(int i = 0; i < (v.end() - v.begin()); i++)
cout << itr[i] << space;
cout << endl;
}
Операции с итераторами произвольного доступа реализуются таким образом, чтобы не чувствовалось разницы между использованием обычных указателей и итераторов.
Итераторы произвольного доступа возвращают такие контейнеры, как vector и deque.
Вспомогательные итераторы
Вспомогательные итераторы названы так потому, что они выполняют вспомогательные операции по отношению к основным.
Реверсивные итераторы. Некоторые классы-контейнеры спроектированы так, что по хранимым в них элементам данных можно перемещаться в заданном направлении. В одних контейнерах это направление от первого элемента к последнему, а в других - от элемента с самым большим значением к элементу, имеющему наименьшее значение. Однако существует специальный вид итераторов, называемых реверсивными. Такие итераторы работают "с точностью до наоборот", то есть если в контейнере итератор ссылается на первый элемент данных, то реверсивный итератор ссылается на последний. Получить реверсивный итератор для контейнера можно вызовом метода rbegin(), а реверсивное значение "за пределом" возвращается методом rend(). Следующий пример использует нормальный итератор для вывода значений от 1 до 5 и реверсивный итератор для вывода этих же значений, но в обратном порядке:
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
main(void)
{
const int init[] = {1, 2, 3, 4, 5};
vector<int> v(5);
copy(init, init + 5, v.begin());
copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));
copy(v.rbegin(), v.rend(), ostream_iterator<int>(cout, " ")); }
Итераторы потоков. Важную роль в STL играют итераторы потоков, которые делятся на итераторы потоков ввода и вывода. Практически во всех рассмотренных примерах имеется итератор потока вывода для отображения данных на экране. Суть применения потоковых итераторов в том, что они превращают любой поток в итератор, используемый точно так же, как и прочие итераторы: перемещаясь по цепочке данных, он считывает значения объектов и присваивает им другие значения.
Итератор потока ввода - это удобный программный интерфейс, обеспечивающий доступ к любому потоку, из которого требуется считать данные. Конструктор итератора имеет единственный параметр - поток ввода. А поскольку итератор потока ввода представляет собой шаблон, то ему передается тип вводимых данных. Вообще-то должно передаваться четыре типа, но последние три имеют значения по умолчанию. Каждый раз, когда требуется ввести очередной элемент информации, используйте оператор ++ точно так же, как с основными итераторами. Считанные данные можно узнать, если применить разыменовывание (*).
Итератор потока вывода весьма схож с итератором потока ввода, но у его конструктора имеется дополнительный параметр, которым указывают строку-разделитель, добавляемую в поток после каждого выведенного элемента. Ниже приведен пример программы, читающей из стандартного потока cin числа, вводимые пользователем и дублирующие их на экране, завершая сообщение строкой - "last entered value". Работа программы заканчивается при вводе числа 999:
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
main(void)
{ istream_iterator<int> is(cin);
ostream_iterator<int> os(cout, " – введенное значение \n");
int input;
while((input = *is)!= 999)
{ *os++ = input;
is++;
}
}
Потоковые итераторы имеют одно существенное ограничение: в них нельзя возвратиться к предыдущему элементу. Единственный способ сделать это - заново создать итератор потока.
Итераторы вставки. Появление итераторов вставки (insert iterator) было продиктовано необходимостью. Без них просто невозможно добавить значения к цепочке объектов. Так, если в массив чисел, на которые ссылается итератор вывода, вы попытаетесь добавить пару новых значений, то итератор вывода попросту запишет новые значения на место старых и они будут потеряны. Любой итератор вставки: front_inserter, back_inserter или inserter - выполнит ту же операцию вполне корректно. Первый из них добавляет объекты в начало цепочки, второй - в конец. Третий итератор вставляет объекты в заданное место цепочки. При всем удобстве итераторы вставки имеют довольно жесткие ограничения. Так, front_inserter и back_inserter не могут работать с наборами (set) и картами (map), а front_inserter к тому же не умеет добавлять данные в начало векторов (vector). Зато итератор вставки inserter добавляет объекты в любой контейнер. Одной интересной особенностью обладает front_inserter: данные, которые он вставляет в цепочку объектов, должны передаваться ему в обратном порядке.
Рассмотрим пример программы, в которой создается список (list) с двумя значениями, равными нулю. После этого в начало и конец списка добавляются значения 1, 2, 3. Третья последовательность 1-1-1 вставляется в середину списка между нулями. Итак, после описания заголовочных файлов мы создаем массивы, необходимые для работы, и контейнер типа "список" из двух элементов:
#include <algorithm>
#include <iostream>
#include <list>
using namespace std;
main(void)
{
int init[] = {0, 0};
int init1[] = {3, 2, 1};
int init2[] = {1, 2, 3};
int init3[] = {1, 1, 1};
list<int> l(2);
Затем список инициализируется нулями из массива init и его значения отображаются на экране:
copy(init, init + 2, l.begin());
copy(l.begin(), l.end(), ostream_iterator<int>(cout, " "));
cout << " - before front_inserter" << endl;
Итератором вставки в начало списка в обратном порядке добавляются значения массива init1, и производится повторный показ данных из списка на экране:
copy(init1, init1 + 3, front_inserter(l));
copy(l.begin(), l.end(), ostream_iterator<int>(cout, " "));
cout << " - before back_inserter" << endl;
Теперь итератор вставки в конец добавит элементы массива init2 в "хвост" списка:
copy(init2, init2 + 3, back_inserter(l));
copy(l.begin(), l.end(), ostream_iterator<int>(cout, " "));
cout << " - before inserter" << endl;
Сложнее всего обстоит дело с итератором inserter. Для него, кроме ссылки на сам контейнер, нужен итератор, указывающий на тот объект в контейнере, за которым будет произведена вставка элементов массива init3. С этой целью мы создаем переменную типа "итератор", инициализируя ее итератором, указывающим на начало списка:
list<int>::iterator& itr = l.begin();
Теперь специальной операцией advance делаем приращение переменной итератора так, чтобы она указывала на четвертый объект в цепочке данных списка:
advance(itr, 4);
Остается добавить данные в цепочку посредством inserter и отобразить содержимое ”списка” на дисплее:
copy(init3, init3 + 3, inserter(l, itr));
copy(l.begin(), l.end(), ostream_iterator<int>(cout, " "));
cout << " - the end!" << endl;
}
Константный итератор. Последний итератор, который мы рассмотрим, - константный (constant iterator). Он образуется путем модификации основного итератора. Константный итератор не допускает изменения данных, на которые он ссылается. Можно считать константный итератор указателем на константу. Чтобы получить константный итератор, можно воспользоваться типом const_iterator, предопределенным в различных контейнерах. К примеру, так можно описать переменную типа константный итератор на список:
list<int>::const_iterator c_itr;
Операции с итераторами
Существуют две важных операции для манипуляции ими. С одной из них - advance - мы познакомились в последнем примере. Это просто удобная форма инкрементирования итератора itr на определенное число n:
void advance (InputIterator& itr, Distance& n);
Вторая операция измеряет расстояние между итераторами first и second, возвращая полученное число через ссылку n:
void distance(InputIterator& first, InputIterator& second, Distance& n);
Контейнерные классы
|
|
|
