Строки стандартного класса string

Строки стандартного класса string

В любой программе, кроме операторов языка, используются средства библиотек, включаемых в среду программирования. Компиляторы Microsoft Visual C++ содержат библиотеки классов для написания приложений Windows. Часть библиотек стандартизована, т.е. должна поставляться с любым компилятором языка.

Стандартную библиотеку С++ можно условно разделить на две части. К первой относятся функции, макросы, типы и константы, унаследованные из библиотеки С, а ко второй – классы, шаблоны и другие средства С++ для ввода, вывода, хранения и обработки данных как стандартных типов, так и типов, определенных пользователем.

В классах можно выделить несколько групп в соответствии с их назначением. Потоковые классы (мы их уже рассматривали) предназначены для управления потоками данных между оперативной памятью и внешними устройствами (дисками, консолью и т.д.), а также в пределах оперативной памяти.

Строковый класс string предназначен для удобной и защищенной от ошибок работы с символьными строками. Рассмотрим работу с ним более подробно.

Операции

Для объектов класса string допустимы операции

операция	действие	операция	действие
=	присваивание	>	лексикографическое сравнение на больше
+	конкатенация (сцепление)	>=	лексикографическое сравнение на больше или равно
==	лексикографическое сравнение на равенство	[ ]	индексация (обращение к элементу)
!=	лексикографическое сравнение на неравенство	<<	вывод
<	лексикографическое сравнение на меньше	>>	ввод
<=	лексикографическое сравнение на меньше или равно	+=	добавление, конкатенация с присвоением результата

 

Для строк класса string (в отличие от строк старого стиля) &s[0] не равно s.

Методы класса string

 

метод	назначение
	получение характеристик строк
at (size_type n)	доступ к n-му элементу строки
size_type size() const;	возвращает размер строки
size_type length() const;	возвращает размер строки,то же самое, что и size()
size_type max_size() const;	возвращает максимальную длину строки
size_type capacity() const;	возвращает объем памяти, занимаемый строкой (емкость)
bool empty() const;	возвращает истину, если строка пустая
	присваивание частей строк
assign (const string& str)	присваивает строку str вызывающей строке: s2.assign(s1); //равносильно s2=s1;
assign (const string& str, size_type pos, size_type n);	присваивает вызывающей строке n символов строки str, начиная с позиции pos;
assign (const char*s, size_type n);	присваивает вызывающей строке n символов строки s старого стиля;
	добавление части одной строки к другой
append (const string& str)	добавляет строку str к концу вызывающей строки, действие эквивалентно операции конкатенации +: s2. append (s1); //равносильно s2+s1;
append (const string& str, size_type pos, size_type n);	добавляет к вызывающей строке n символов строки str, начиная с позиции pos;
append (const char*s, size_type n);	добавляет к вызывающей строке n символов строки s старого стиля;
	вставка в одну строку части другой строки
insert (size_type pos1, const string& str);	вставляет строку str в вызывающую строку, начиная с позиции pos1
insert (size_type pos1, const string& str, size_type pos2, size_type n);	вставляет в вызывающую строку, начиная с позиции pos1 n символов строки str, начиная с позиции pos2
insert (size_type pos, const char*s, size_type n);	вставляет в вызывающую строку n символов строки s старого стиля;
	замена части строки
replace (size_type pos1, size_type n1, const string& str);	заменяет n1 элементов, начиная с позиции pos1 вызывающей строки, элементами строки str
replace (size_type pos1, size_type n1, const string& str, size_type pos2, size_type n2);	заменяет n1 элементов, начиная с позиции pos1 вызывающей строки, n2 элементами строки str, начиная с позиции pos2
replace (size_type pos1, size_type n1, const char*s, size_type n2);	заменяет n1 элементов, начиная с позиции pos1 вызывающей строки, n2 элементами строки s старого стиля
	удаление части строки
erase (size_type pos=0, size_type n= npos); npos-самое большое число >0 типа size_type, статический член класса string	удаляет n элементов, начиная с позиции pos (если n не задано, то удаляется весь остаток строки)
	выделение части строки
string substr (size_type pos=0, size_type n = npos) const;	возвращает подстроку длиной n, начиная с позиции pos
	обмен содержимого двух строк
swap(string& str);	обменивает содержимое вызывающей строки и строки str
	поиск подстрок
size_type find (const string& str, size_type pos=0) const;	ищет самое левое вхождение строки str в вызывающую строку, начиная с позиции pos; возвращает позицию вхождения, или npos, если вхождение не найдено
size_type find (char c, size_type pos=0) const;	ищет самое левое вхождение символа c, начиная с позиции pos; возвращает позицию вхождения или npos, если вхождение не найдено
size_type find_first_not_of (const string& str, size_type pos=0) const;	ищет самое левое вхождение в вызывающую строку, начиная с позиции pos, символа, отличного от указанных в строке str; возвращает позицию вхождения, или npos, если вхождение не найдено
size_type rfind (char c, size_type pos=0) const;	ищет самое правое вхождение символа c, начиная с позиции pos
size_type find_first_of (const string& str, size_type pos=0) const;	ищет самое левое вхождение любого символа cтроки str, начиная с позиции pos
size_type find_first_of (char c, size_type pos=0) const;	ищет самое левое вхождение символа c в вызывающую cтрокуr, начиная с позиции pos, и возвращает позицию символа или npos, если вхождение не найдено
size_type find_last_of (const string& str, size_type pos=0) const;	ищет самое правое вхождение любого символа cтроки str, начиная с позиции pos
size_type find_last_of (char c, size_type pos=npos) const;	ищет самое правое вхождение любого символа cтроки str, начиная с позиции pos, и возвращает позицию символа или npos, если вхождение не найдено
	сравнение частей строк
int compare (const string& str)const	сравнение двух строк целиком, возвращает значение <0, если вызывающая строка лексикографически меньше str, =0, если строки равны и >0, если вызывающая строка больше
int compare (size_type pos1, size_type n1, const string& str) const	сравнение со строкой str n1 символов вызывающей строки, начиная с позиции pos
int compare (size_type pos1, size_type n1, const string& str, size_type pos2, size_type n2) const	n1 символов вызывающей строки, начиная с позиции pos1, сравниваются с подстрокой строки str длиной n2 символов, начиная с позиции pos2
	преобразование объектов типа string в строки старого стиля
const char* c_str() const;	возвращает указатель на С-строку, содержащую копию вызываемой строки; полученную С-строку нельзя пытаться изменить
	копирование в массив части вызывающей строки
size_type copy (char* s, size_type n, size_type pos=0) const;	копирует в символьный массив s n элементов вызывающей строки, начиная с позиции pos; нуль-символ в результирующий массив не заносится; метод возвращает количество скопированных элементов;

 

size_type – синоним типа unsigned int, определенного в пространстве имен std;

npos – константа, определенная в string, задающая максимально возможное число
(-1), которое в зависимости от контекста означает либо «все элементы» строки, либо отрицательный результат поиска.

Примеры использования методов строк-объектов

Примеры работы со строками разных типов

#include <cstring>

#include <string> //строковый класс

 

int main() {

char c1[80], c2[80], c3[80]; //строки с завершающим нулем

string s1, s2, s3; //строки-объекты

 

//копирование строк

strcpy (c1,"old string one "); //дает warning C4996
// strcpy_s (string, "Hello world from "); не дает warning C4996

strcpy (c2, c1); //дает warning C4996

s1 = "new string one ";

s2 = s1;

cout << c1 <<"\n";

cout << c2 <<"\n";

cout << s1 <<"\n";

cout << s2 <<"\n";;

 

//конкатенация строк

strcpy(c3,c1); //дает warning C4996

strncat (c3,c2,strlen(c2)); //дает warning C4996

// strncat_s (string, "Hello world from "); не дает warning C4996

s3=s1+s2;

cout << c3 <<"\n";

cout << s3 <<"\n";

 

//сравнение строк

if (strcmp(c2, c3) <0) cout << c2;

else cout << c3;

cout << "\n";

 

if (s2 < s3) cout << s2;

else cout << s3;

cout << "\n";

 

getch();

return 0;

}

 

Ввод-вывод

#include <string>

int main() {

string s;

cout << "input slova:" << endl;

cin >> s; //ввод до первого пробельного символа

cout << s << endl; //вывод строки

cin.get(); //удаление из потока символа ‘\n’

cout << "input c probelami:" << endl;

getline(cin,s); //ввод строки с пробелами

cout << s << endl;

cout << "input strok c $:" << endl;

getline(cin,s,'$'); //ввод строки до символа завершения '$'

cout << s << endl;

_getch();

return 0;

}

 

// ввод-вывод

#include <string>

int main()

{

string full_name, nickname, address;

string greeting("Hello, ");

 

cout << "Enter your full name: ";

getline(cin, full_name); //ввод строки с пробелами

cout << "Your full name is: " << full_name << endl;

 

cout << "Enter your nickname: ";

cin >> nickname; //ввод строки-объекта

 

greeting += nickname; //добавление имени к строке-приветствию

cout << greeting << endl; //вывод: "Hello, Jim"

 

cout << "Enter your address on separate lines\n";

cout << "Terminate with '$'\n";

getline(cin, address, '$'); //ввод нескольких строк

cout << "Your address is: " << address << endl;

_getch();

return 0;

}

Результаты работы программы:

Enter your full name: lar str

Your full name is: lar str

Enter your nickname: mama

Hello, mama

Enter your address on separate lines

Terminate with '$'

aaa

bbb

ccc$

Your address is:

aaa

bbb

ccc

 

Методы корректировки

#include <string>

int main()

{

string s1("Quick! Send for Count Graystone.");

string s2("Lord");

string s3("Don't ");

 

s1.erase(0, 7); //удаление "Quick! "

s1.replace(9, 5, s2); //замена "Count" на "Lord"

s1.replace(0, 1, "s"); //замена 'S' на 's'

s1.insert(0, s3); //вставка "Don't " в начало

s1.erase(s1.size()-1, 1); //удаление '.'

s1.append(3, '!'); //добавление "!!!"

 

size_t x = s1.find(' '); //поиск пробела и возврат его позиции

while(x < s1.size()) //продолжать пока пробел не найден

{

s1.replace(x, 1, "/"); //замена пробела на слэш

x = s1.find(' '); //поиск следующего пробела

}

cout << "s1: " << s1 << endl;

_getch();

return 0;

}

 

Результаты работы программы:

s1: Don't/send/for/Lord/Graystone!!!

 

//методы assign, insert, erase, replace

#include <string>

int main() {

string s0, s01, s02,s03, s04;

s0.assign("aabb"); //s0=”aabb”

s01.assign(s0); //s01=s0

s02.assign("ccc"); //s02=”ccc”

s03.assign(s01,2,1); //s03 присваивается 2-ой символ из s01

s04.assign("abcd",3); //s04 присваивается первые 3 символa строки "abcd"

cout << "s0= " <<s0<< endl; //

cout << "s01= " <<s01 << endl;

cout << "s02= " <<s02 <<endl;

cout << "s03= " <<s03 <<endl;

cout << "s04= " <<s04 <<endl;

 

string s1 ("a"), s2("ok"), s3("les");

cout << "s1= " <<s1<< endl; //

cout << "s2= " <<s2 << endl;

cout << "s3= " <<s3 <<endl;

 

// insert, erase:

cout << "s3: " <<s3.insert(3,s1) << endl; //lesa

cout << "s3: " <<s3.insert(3,s2) <<endl; //lesoka

cout << "s3: " <<s3.erase(5,1) <<endl; //lesok

cout << "s3: " <<s3.insert(5,s1) <<endl; //lesoka

cout << "s3: " <<s3.erase(3,1) <<endl; //leska

 

// replace:

cout << "s3= " <<s3.replace(1,1,s1, 0,1) <<endl; //laska

string s ("mam");

cout << s.at(1) << endl; //будет выведен символ a

s.at(1)='o'; //символ a заменится на символ o

cout << s.at(1)<< "\n";

_getch();

return 0;

}

Результаты работы программы:

s0= aabb

s01= aabb

s02= ccc

s03= b

s04= abc

s1= a

s2= ok

s3= les

s3: lesa

s3: lesoka

s3: lesok

s3: lesoka

s3: leska

s3= laska

a

o

 

Методы сравнения

#include <string>

int main()

{

string aName = "George";

string userName;

 

cout << "Enter your first name: ";

cin >> userName;

if (! userName.compare("")) {cout << "pusto" << endl;

return 1;}

 

if(userName==aName) //operator ==

cout << "Greetings, George\n";

else if(userName < aName) //operator <

cout << "You come before George\n";

else

cout << "You come after George\n";

//или

if (!userName.compare(aName)) cout <<" = ";

else

if (userName.compare(aName)<0) cout <<" < ";

else cout << " > ";

 

 

int n = userName.compare(0, 2, aName, 0, 2); //функция compare()

cout << "The first two letters of your name ";

if(n==0)

cout << "match ";

else if(n < 0)

cout << "come before ";

else

cout << "come after ";

cout << aName.substr(0, 2) << endl;

 

_getch();

return 0;

}

 

Результаты работы программы:

Enter your first name: George

Greetings, George

The first two letters of your name match Ge

или:

Enter your first name: Ivan

You come after George

The first two letters of your name come after Ge

 

Методы поиска подстроки

#include <string>

int main()

{

string s1 =

"In Xanadu did Kubla Kahn a stately pleasure dome decree";

size_t n;

n = s1.find("Kubla"); // в строке s1 ищется самое левое
// вхождение данной строки

cout << "Found Kubla at " << n << endl;

 

n = s1.find_first_of("spde"); // в строке s1 ищется
//первое вхождение любого из

// символов данной строки

cout << "First of spde at " << n << endl;

 

n = s1.find_first_not_of("aeiouAEIOU"); //в исходной строке ищется
//первое вхождение символа,

//отличного от указанных в данной строке

cout << "First consonent at " << n << endl;

_getch();

return 0;

}

Результаты работы программы:

Found Kubla at 14

First of spde at 7

First consonent at 1

 

Int main ()

{

string word, curword;

cout << "input" << endl; cin >> word;

ifstream fin ("infile.txt", ios::in);

if(!fin) {cout << "error" << endl; _getch(); return 1;}

int count =0;

while (!fin.eof()) {

fin >> curword;

if (equal(curword, word)) count++;

}

cout << count << endl;

_getch();

return 0;

}

 

bool equal(const string& cw, const string& w)

{

char punct[]= {'.',',','?','!'};

if (cw==w) return true;

for (int i=0; i< sizeof(punct); ++i)

if (cw==w + punct[i]) return true;

return false;

}

 

Int main ()

{

ifstream fin ("aaaaa.txt", ios::in);

if(!fin) {cout << "error" << endl; _getch(); return 1;}

int count =0;

string word;

ostringstream sentence;

 

while (true) {

char symb;

while (isLimit(symb = fin.peek())) { //если разделитель

sentence << symb; //записывем его в поток

if (symb=='\n') break;

fin.seekg(1, ios::cur);

}

fin >> word; //читаем из файла слово

if (fin.eof()) break;

sentence << word; //записываем слово в строковый поток

char last = word[word.size() - 1]; //выделяем последний символ слова

if ((last=='.')|| (last == '!')) { //если предложение не?

sentence.str(""); //очистка строкового потока

continue;

}

if (last=='?') {

cout << sentence. str (); //вывод содержимого потока

sentence.str(""); //очистка потока

count++;

}

}

if (!count) cout << "? net " << endl;

 

_getch();

return 0;

}

 

bool isLimit(char c) {

char lim[]= {' ','\t','\n'};

for (int i=0; i< sizeof(lim); ++i)

if (c==lim[i]) return true;

return false;

}

Часть библиотеки, в которую входят контейнерные классы, алгоритмы и итераторы, называют стандартной библиотекой шаблонов (STL – Standard Template Library). В основе архитектурных решений библиотеки STL лежат следующие особенности.

Первая особенность – разделение данных и операций ( принципы противоположны принципам ООП, где объект соединяет данные и операции ). Концепция STL основана на отделении данных от операций. Данные хранятся в контейнерах, а операции определяются адаптируемыми алгоритмами. Разные алгоритмы по мере необходимости применяются к разным контейнерам. За счет этого отделения достигнуты гибкость и компактность библиотеки STL.

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

Третья особенность – применение итераторов. Итераторы как бы «склеивают» контейнеры и алгоритмы, благодаря чему любой алгоритм может работать практически с любым контейнером.

Для использования контейнеров и адаптеров необходимо подключать стандартные заголовочные файлы:

заголовочный файл	назначение
#include<vector>	вектор
#include<deque>	двусторонняя очередь
#include<list>	двусвязный список
#include<stack>	стек
#include<queue>	очередь, очередь с приоритетами
#include<set>	множество, множество с дубликатами
#include<map>	словарь, словарь с дубликатами
#include<bitset>	последовательность битов, битовое множество

 

Для использования алгоритмов и итераторов необходимо подключать стандартные заголовочные файлы:

заголовочный файл	назначение
#include<algorithm>	алгоритмы
#include<functional>	функциональные объекты
#include<iterator>	итераторы

 

Контейнеры

В STL контейнер – это параметризованный класс, представляемый шаблоном классов. Объект такого параметризованного класса пригоден для включения других объектов, поэтому один и тот же вид контейнера можно использовать для хранения данных различных типов (встроенных, либо пользовательских). Элементами контейнеров могут быть и контейнеры.

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

Использование контейнеров позволяет повысить надежность программ, их переносимость и универсальность, уменьшить сроки разработки. В то же время эти преимущества отражаются на быстродействии программы (оно снижается). Для эффективного использования контейнеров требуется вдумчивое освоение библиотеки STL.

 

Для каждого типа контейнера определены методы для работы с его элементами, не зависящие от конкретного типа данных, которые хранятся в контейнере, Выбор вида контейнера зависит от того, что требуется делать с данными в программе.

Контейнеры могут быть фиксированного или переменного размера.

Способ доступа к элементам контейнера:

· прямой – доступ по индексу элемента;

· последовательный – последовательное перемещение от элемента к элементу;

· ассоциативный – похож на прямой, однако основан не на индексах элементов, а на их содержимом (поле, с содержимым которого ассоциируется элемент контейнера, называется ключом).

Тип контейнера – это способ доступа к его элементам (но не тип его элементов):

Для представления различных структур данных (коллекций) в STL определены контейнеры двух видов:

· Последовательные контейнеры, представляющие собой упорядоченные коллекции, в которых каждый элемент занимает позицию, не зависящую от значения элемента. Позиция может зависеть от того, какой была коллекция в момент помещения в нее элемента и/или от явного указания места для размещаемого элемента. Последовательные контейнеры обеспечивают хранение конечного количества однотипных величин в виде непрерывной неупорядоченной последовательности. К ним относятся двусторонние очереди (deque), списки (list), векторы (vector), а также так называемые адаптеры, то есть варианты контейнеров – стеки (stack), очереди (queue) и очереди с приоритетами (priority_queue).

· Ассоциативные контейнеры, представляющие собой отсортированные по умолчанию коллекции однотипных элементов, в которых позиция элемента зависит от его значения. Ассоциативные контейнеры автоматически упорядочивают включаемые в них элементы по некоторому критерию. Критерий реализуется в виде функции, которая сравнивает либо значения элементов, либо специальные ключи, заданные для этих значений (элементов). Ассоциативные контейнеры реализуются в виде бинарных деревьев, где у каждого узла-элемента есть два узла–потомка (правый и левый). Все производные узлы слева имеют меньшие значения, а все производные справа – большие. К ассоциативным контейнерам относят: словари (map), словари с повторяющимися элементами (multimap), множества (set), множества с повторяющимися элементами (multiset), битовые множества (bitset).

 

Сравнение контейнеров

Для однотипных контейнеров сравнение может быть выполнено с помощью стандартных операций отношений ==,!=, <, <=, >, >=.

Отношения <, <=, >, >= проверяются по лексикографическому критерию. В этом случае два контейнера сравниваются с учетом интервалов размещения элементов [beg1, end1) и [beg2, end2). Элементы из интервалов сравниваются попарно до тех пор, пока не будет выполнено одно из условий:

· если очередные два элемента не равны, то результат этих элементов сравнения определяет результат сравнения контейнеров;

· если интервалы не равны, то при парном сравнении элементов может быть достигнут конец меньшего интервала, а истинность проверяемого условия еще не установлена. В этом случае контейнер с меньшим количеством элементов считается меньшим.

Методы частного применения

 

push_back() – вставка элемента в конец контейнера; применим к деку, вектору, списку.

push_front() – вставка элемента в начало контейнера; применим к деку, списку.

 

pop_back() – удаление последнего элемента контейнера; применим к деку, вектору, списку.

pop_front() – удаление элемента из начала контейнера; применим к деку, списку

Методы pop_back() и pop_front() не возвращают удаленное значение.

Для считывания первого элемента используется метод front(), а для считывания последнего элемента – метод back().

 

Контейнер vector эффективно обрабатывает произвольную выборку элементов с помощью операции индексации [] или метода at, который аналогичен операции индексации, но в отличие от нее проверяет выход за границу вектора (генерирует исключение out_of_range, если такое нарушение обнаруживается).

 

Действия методов вставки и удаления:

 

push_back() push_front()

элементы последовательности

 

pop_back() pop_front()

 

Применение представленных в таблице методов дает разную эффективность для разных контейнеров:

Название операции	метод	vector	deque	list
добавление в начало	push_front()	-	O(1)	O(1)
удаление из начала	pop_front()	-	O(1)	O(1)
добавление в конец	push_back()	O(1)+	O(1)	O(1)
удаление из конца	pop_back()	O(1)+	O(1)	O(1)
вставка в произвольное место	insert()	O(n)+	O(n)	O(1)
удаление из произвольного места	erase()	O(n)+	O(n)	O(1)
обращение по индексу с проверкой допустимости	at()	O(1)	O(1)	-
обращение по индексу без проверки допустимости	[ ]	O(1)	O(1)	-
доступ к первому элементу	front()	O(1)	O(1)	O(1)
доступ к последнему элементу	back()	O(1)	O(1)	O(1)

 

Обозначения в таблице:

O(1) – длительность операции не зависит от числа элементов в контейнере;

O(n) – длительность операции пропорциональна числу элементов в контейнере;

+ – суффикс, обозначающий, что длительность исполнения операции может возрастать;

- – неприменимость операции к контейнеру.

Итераторы

Каждый контейнер включает тип с названием итератор.В шаблоне контейнера с параметром Т этому типу соответствуют Т* или const Т*, т.е. итератор ведет себя как указатель на элемент, помещенный в контейнер. Итератор – объект, по своим функциям напоминающий указатель при работе с массивом, аналог указателя на элемент. Он используется для обеспечения доступа к элементам контейнера, для просмотра контейнера в прямом или обратном направлении. От него требуется умение ссылаться на элемент контейнера и реализовывать операции перехода к следующему элементу. При помощи итераторов можно просматривать контейнеры, не заботясь о фактических типах данных, используемых для доступа к элементам. Константные итераторы используются тогда, когда значений соответствующих элементов контейнера не изменяются.

Существуют итераторы:

· однонаправленные (прямые); если нужно продвигаться вперед, но при этом совершать как запись, так и чтение, используется «прямой» итератор;

· двунаправленные;

· обеспечивающие произвольное перемещение (произвольный доступ); итератор «произвольного доступа» обеспечивает доступ к элементу контейнера без всяких продвижений.

 

Имеются два специализированных типа итераторов:

· потоковые итераторы, благодаря которым входные и выходные потоки могут вести себя как итераторы:

§ ostream_iterator – итератор выходного потока; используется, если требуется только лишь продвинуться на один шаг по контейнеру для осуществления последовательной записи, например, при записи в файл или выводе на экран;

§ istream_iterator – итератор входного потока; используется, если требуется только лишь продвинуться на один шаг по контейнеру. для осуществления последовательного чтения, например, при чтении из файлов или с клавиатуры.

 

· адаптеры итераторов – варианты модификации обычного итератора, которые могут необычным способом изменять поведение обычных итераторов:

o обратный итератор (reverse_iterator) для реверсного прохода контейнера (в обратном направлении);

o итератор вставки:

§ back_inserter вставляет новые элементы в конец контейнера

§ front_inserter вставляет новые элементы в начало контейнера (кроме вектора)

§ inserter вставляет новые элементы в указанное место

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

 

Тип итератора	Шаг вперед ++	Шаг назад --	Чтение value=*i	Запись *i= value	Произвольный доступ
Произвольного доступа	х	х	х	х	х
Двунаправленный	х	х	х	х
Однонаправленный	х		х	х
Входной	х		х
Выходной	х			х

 

 

Для просмотра контейнеров с помощью итераторов в каждом контейнере определены методы:

 

метод	пояснение
iterator begin() const_iterator begin() const	указывают на первый элемент
iterator end() const_iterator end() const	указывают на элемент, следующий за последним
reverse_iterator rbegin() const_reverse_iterator rbegin() const	указывают на первый элемент в обратной последовательности, который инкрементируется (при использовании обратного итератора)
reverse_iterator rend() const_reverse_iterator rend() const	указывают на элемент, следующий за последним, в обратной последовательности (при использовании обратного итератора)

 

Алгоритмы

Алгоритм – независимая шаблонная функция, производящая действия над элементами контейнера (для ее использования к программе подключается заголовочный файл <algorithm>). Алгоритмы можно использовать и при работе с обычными массивами С++.

Наиболее популярные алгоритмы STL:

название	назначение	аргументы
adjacent_find	поиск смежных пар одинаковых значений в последовательности; возвращает итератор первой пары поиск смежных пар одинаковых значений в последовательности, удовлетворяющих заданному предикатом условию в виде функции; возвращает итератор первой пары	first, last     first, last, predicate
accumulate	вычисление суммы элементов в заданном диапазоне; последовательное применение к каждому объекту диапазона формулы: init= init+*iter	first, last, init
binary_search	бинарный поиск в упорядоченной последовательности	first, last, val first, last, val, predicate
сopy	копирование объектов из первого диапазона во второй	first1, last1, first2
copy_backward	копирование объектов из первого диапазона во второй, располагая их в обратном порядке от last2 к first2	first1, last1, first2
count	возвращает количество вхождений n элемента value в последовательность	first, last, value, n
count_if	подсчет количества n выполнений в последовательности условия, удовлетворяющего значению predicate	first, last, predicate, n
еqual	определяет идентичность двух диапазонов; определяет идентичность двух диапазонов в соответствии с условием	first1, last1, first2 first1, last1, first2, predicate
fill	заменяет все элементы заданным значением	value
fill_n	заполняет диапазон от first до first+n заданным значением value	first, n, value
find	возвращает итератор, указывающий на первый объект, равный значению value	first, last, value
find_if	возвращает итератор, указывающий на первый объект, для которого условие принимает значение true	first, last, predicate
find_end	поиск конца последовательности [first2, last2] внутри диапазона [first1, last1] поиск конца последовательности [first2, last2] для некоторого условия внутри диапазона [first1, last1]	first1, last1, first2, last2   first1, last1, first2, last2, predicate
find_first_of	нахождение первого значения из одной последовательности в другой нахождение первого значения из одной последовательности в другой в соответствии с условием	first1, last1, first2, last2   first1, last1, first2, last2, predicate
for_each	вызов function для каждого элемента последовательности	first, last, function
generate	присваивает всем элементам значения, получаемые с помощью последовательных вызовов функции gen	first, last, gen
generate_ n	присваивает всем элементам диапазона от first до first+n значения, получаемые с помощью последовательных вызовов функции gen	first, n, gen
includes	определяет, включает ли одна последовательность все элементы другой последовательности определяет, включает ли одна последовательность все элементы другой последовательности в соответствии с условием	first1, last1, first2, last2     first1, last1, first2, last2, predicate
inplace_merge	слияние диапазонов, отсортированных в порядке возрастания элементов; слияние диапазонов, отсортированных в соответствии с условием	first, middle, last   first, middle, last, predicate
iter_swap	меняет местами значения	left, right
lexicographical_compare	лексикографическое сравнение последовательностей лексикографическое сравнение последовательностей в соответствии с условием	first1, last1, first2, last2   first1, last1, first2, last2, predicate
lower_bound	нахождение первого значения в последовательности, которое не меньше заданного value	value
max	возвращает максимальный из двух элементов	value1, value2
max_element	возвращает итератор максимального элемента внутри диапазона возвращает итератор максимального элемента внутри диапазона в соответствии с условием	first, last   first, last, predicate
merge	соединяет отсортированные диапазоны 1 и 2 в диапазон 3 соединяет отсортированные диапазоны 1 и 2 в диапазон 3; порядок сортировки определяется функцией comp	first1, last1, first2, last2, first3   first1, last1, first2, last2, first3, comp
min	возвращает минимальный из двух элементов	value1, value2
min_element	возвращает итератор минимального элемента внутри диапазона возвращает итератор минимального элемента внутри диапазона в соответствии с условием	first, last   first, last, predicate
mismatch	поиск первого несовпадения между элементами двух последовательностей; возвращаются итераторы несовпадающих элементов поиск первого несовпадения между элементами двух последовательностей в соответствии с условием; возвращаются итераторы несовпадающих элементов	first1, last1, first2   first1, last1, first2, predicate
remove	удаляет из диапазона все объекты, равные value	first, last, value
remove_copy	копирует все объекты, не равные значению value, из диапазона 1 в диапазон 2	first1, last1, first2, value
remove_copy_if	копирует все объекты, не удовлетворяющие predicate, из диапазона 1 в диапазон 2	first1, last1, first2, predicate
replace	заменяет все объекты, равные old, объектами, равными new	first, last, old, new
replace_if	заменяет все объекты, удовлетворяющие predicate, объектами, равными new	first, last, predicate, new
replace_copy	производит копирование из диапазона 1 в диапазон 2, заменяя все объекты, равные old, объектами, равными new	first1, last1, first2, old, new
replace_copy_if	производит копирование из диапазона 1 в диапазон 2, заменяя все объекты, удовлетворяющие predicate, объектами, равными new	first1, last1, first2, predicate, new
reverse	обращает последовательность элементов из диапазона	first, last
reverse_copy	копирует объекты из диапазона 1 в диапазон 2 в обратном порядке	first1, last1, first2
search	проверяет, содержится ли второй диапазон внутри первого; возвращает начало совпадения или last1, если нет совпадения	first1, last1, first2, last2
search	проверяет, содержится ли второй диапазон внутри первого, равенство определяется по predicate; возвращает начало совпадения или last1, если нет совпадения	first1, last1, first2, last2, predicate
sort	сортирует объекты в диапазоне	first, last
sort	сортирует объекты в диапазоне, используя comp в качестве функции сравнения	first, last, comp
swap	заменяет один объект другим	a, b
iter_swap	обменивает объекты, на которые указывают два итератора	iter1, iter2
swap_ranges	обменивает соответствующие объекты в двух диапазонах	first1, last1, first2

 

В списках параметров всех алгоритмов первые два параметра задают диапазон обрабатываемых элементов в виде полуинтервала [first, last), где first – итератор, указывающий на начало диапазона, а last – итератор, указывающий на выход за границы диапазона, т.е. на элемент, распол