Chapter 1. Абстрактные контейнерные типы

§ 1.1. Система текстового поиска

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

Если одно или несколько слов запроса найдены, печатается количество их вхождений. По желанию пользователя печатаются предложения, содержащие найденные слова. Например, если нужно найти все вхождения словосочетаний Civil War и Civil Rights, запрос может выглядеть таким образом :

Civil && (War || Rights)

Результат запроса:

Civil: 12 вхождений
War: 48 вхождений
Rights: 1 вхождение
Civil && War: 1 вхождение
Civil && Rights: 1 вхождение
(8) Civility, of course, is not to be confused with
Civil Rights, nor should it lead to Civil War

Здесь (8) представляет собой номер предложения в тексте. Наша система должна печатать фразы, содержащие найденные слова, в порядке возрастания их номеров (т.е. предложение номер 7 будет напечатано раньше предложения номер 9), не повторяя одну и ту же несколько раз.

Наша программа должна уметь:

• запросить имя текстового файла, а затем открыть и прочитать этот файл;
• организовать внутреннее представление этого файла так, чтобы впоследствии соотнести найденное слово с предложением, в котором оно встретилось, и определить порядковый номер этого слова;
• понимать определенный язык запросов. В нашем случае он включает следующие операторы:

  && два слова непосредственно следуют одно за другим в строке
  || одно или оба слова встречаются в строке
  ! слово не встречается в строке
  () группировка слов в запросе

Используя этот язык, можно написать:

Lincoln

чтобы найти все предложения, включающие слово Lincoln, или

! Lincoln

для поиска фраз, не содержащих такого слова, или же

(Abe || Abraham) && Lincoln

для поиска тех предложений, где есть словосочетания Abe Lincoln или Abraham Lincoln.

Представим две версии нашей системы. В этой главе мы решим проблему чтения и хранения текстового файла в отображении, где ключом является слово, а значением – номер строки и позиции в строке. Мы обеспечим поиск по одному слову. (В главе 17 мы реализуем полную систему поиска, поддерживающую все указанные выше операторы языка запросов с помощью класса Query.) .

Возьмем шесть строчек из неопубликованного детского рассказа Стена Липпмана (Stan Lippman) :

Рис. 2.

Alice Emma has long flowing red hair. Her Daddy says when the wind blows through her hair, it looks almost alive, like a fiery bird in flight. A beautiful fiery bird, he tells her, magical but untamed. "Daddy, shush, there is no such thing," she tells him, at the same time wanting him to tell her more. Shyly, she asks, "I mean. Daddy, is there?"

После считывания текста его внутреннее представление выглядит так (процесс считывания включает ввод очередной строки, разбиение ее на слова, исключение знаков препинания, замену прописных букв строчными, минимальная поддержка работы с суффиксами и исключение таких слов, как and, a, the):

alice ((0,0))
alive ((1,10))
almost ((1,9))
ask ((5,2))
beautiful ((2,7))
bird ((2,3),(2,9))
blow ((1,3))
daddy ((0,8),(3,3),(5,5))
emma ((0,1))
fiery ((2,2),(2,8))
flight ((2,5))
flowing ((0,4))
hair ((0,6),(1,6))
has ((0,2))
like ((2,0))
long ((0,3))
look ((1,8))
magical ((3,0))
mean ((5,4))
more ((4,12))
red ((0,5))
same ((4,5))
say ((0,9))
she ((4,0),(5,1))
shush ((3,4))
shyly ((5,0))
such ((3,8))
tell ((2,11),(4,1),(4,10))
there ((3,5),(5,7))
thing ((3,9))
through ((1,4))
time ((4,6))
untamed ((3,2))
wanting ((4,7))
wind ((1,2))

Ниже приводится пример работы программы, которая будет реализована в данном разделе (то, что задает пользователь, выделено курсивом):

please enter file name: alice_emma
enter a word against which to search the text.
to quit, enter a single character ==> alice
alice occurs 1 time:
     (line 1) Alice Emma has long flowing red hair. Her Daddy says
enter a word against which to search the text.
to quit, enter a single character ==> daddy
daddy occurs 3 times:
     (line 1) Alice Emma has long flow-ing red hair. Her Daddy says
     (line 4) magical but untamed. "Daddy, shush, there is no such thing,"
     (line 6) Shyly, she asks, "I mean, Daddy, is there?"
enter a word against which to search the text.
to quit, enter a single character ==> phoenix
Sorry. There are no entries for phoenix.
enter a word against which to search the text.
to quit, enter a single character ==> .
Ok, bye!

Для того чтобы реализация была достаточно простой, необходимо детально рассмотреть стандартные контейнерные типы и тип string.

§ 1.2. Вектор или список?

Первая задача, которую должна решить наша программа, – это считывание из файла заранее неизвестного количества слов. Слова хранятся в объектах типа string. Возникает вопрос: в каком контейнере мы будем хранить слова – в последовательном или ассоциативном?

С одной стороны, мы должны обеспечить возможность поиска слова и, в случае успеха, извлечь относящуюся к нему информацию. Отображение std::map является самым удобным для этого классом.

Но сначала нам нужно просто сохранить слова для предварительной обработки – исключения знаков препинания, суффиксов и т.п. Для этой цели последовательный контейнер подходит гораздо больше. Что же нам использовать: вектор или список?

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

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

Вектор представляет собой область памяти, где элементы хранятся друг за другом. Для этого типа произвольный доступ (возможность извлечь, например, элемент 5, затем 15, затем 7 и т.д.) можно реализовать очень эффективно, поскольку каждый из них находится на некотором фиксированном расстоянии от начала. Однако вставка, кроме случая добавления в конец, крайне неэффективна: операция вставки в середину вектора потребует перемещения всего, что следует за вставляемым. Особенно это сказывается на больших векторах. (Класс deque устроен аналогично, однако операции вставки и удаления самого первого элемента работают в нем быстрее; это достигается двухуровневым представлением контейнера, при котором один уровень представляет собой реальное размещение элементов, а второй уровень адресует первый и последний из них.)

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

Вот некоторые критерии для выбора одного из последовательных контейнеров:

• если требуется произвольный доступ к элементам, вектор предпочтительнее;
• если количество элементов известно заранее, также предпочтительнее вектор;
• если мы должны иметь возможность вставлять и удалять элементы в середину, предпочтительнее список;
• если нам не нужна возможность вставлять и удалять элементы в начало контейнера, вектор предпочтительнее, чем deque.

Как быть, если нам нужна возможность и произвольного доступа, и произвольного добавления/удаления элементов? Приходится выбирать: тратить время на поиск элемента или на его перемещение в случае вставки/удаления. В общем случае мы должны исходить из того, какую основную задачу решает приложение: поиск или добавление элементов? (Для выбора подхода может потребоваться измерение производительности для обоих типов контейнеров.) Если ни один из стандартных контейнеров не удовлетворяет нас, может быть, стоит разработать свою собственную, более сложную, структуру данных.

Какой из контейнеров выбрать, если мы не знаем количества его элементов (он будет динамически расти) и у нас нет необходимости ни в произвольном доступе, ни в добавлении элементов в середину? Что в таком случае более эффективно: список или вектор? (Мы отложим ответ на этот вопрос до следующего раздела.)

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

Внутреннее представление вектора и управление занимаемой им памятью более сложны. Мы рассмотрим это в следующем разделе.

Упражнение 6.1: Что лучше выбрать в следующих примерах: вектор, список или двустороннюю очередь? Или ни один из контейнеров не является предпочтительным?

1. Неизвестное заранее количество слов считывается из файла для генерации случайных предложений.
2. Считывается известное количество слов, которые вставляются в контейнер в алфавитном порядке.
3. Считывается неизвестное количество слов. Слова добавляются в конец контейнера, а удаляются всегда из начала.
4. Считывается неизвестное количество целых чисел. Числа сортируются и печатаются.

§ 1.3. Как растет вектор?

Вектор может расти динамически. Как это происходит? Он должен выделить область памяти, достаточную для хранения всех элементов, скопировать в эту область все старые элементы и освободить ту память, в которой они содержались раньше. Если при этом элементы вектора являются объектами класса, то для каждого из них при таком копировании вызываются конструктор и деструктор. Поскольку у списка нет необходимости в таких дополнительных действиях при добавлении новых элементов, кажется очевидным, что ему проще поддерживать динамический рост контейнера. Однако на практике это не так. Давайте посмотрим почему.

Вектор может запрашивать память не под каждый новый элемент. Вместо этого она запрашивается с некоторым запасом, так что после очередного выделения вектор может поместить в себя некоторое количество элементов, не обращаясь за ней снова. (Каков размер этого запаса, зависит от реализации.) На практике такое свойство вектора обеспечивает значительное увеличение его эффективности, особенно для небольших объектов. Давайте рассмотрим некоторые примеры из реализации стандартной библиотеки С++ от компании Rogue Wave. Однако сначала определим разницу между размером и емкостью контейнера.

Емкость – это максимальное количество элементов, которое может вместить контейнер без дополнительного выделения памяти. (Емкостью обладают только те контейнеры, в которых элементы хранятся в непрерывной области памяти, – std::vector, deque и string. Для контейнера list это понятие не определено.) Емкость может быть получена с помощью функции capacity(). Размер – это реальное количество элементов, хранящихся в данный момент в контейнере. Размер можно получить с помощью функции size(). Например:

#include <vector>
#include <iostream>

int main() {
   std::vector<int> ivec;
   std::cout << "ivec: размер: " << ivec.size()
        << " емкость: " << ivec.capacity() << std::endl;
   for (int ix = 0; -ix < 24; ++ix) {
      ivec.push_back(ix);
      std::cout << "ivec: размер: " << ivec.size()
           << " емкость: " << ivec.capacity() << std::endl;
   }
}

В реализации Rogue Wave и размер, и емкость ivec сразу после определения равны 0. После вставки первого элемента размер становится равным 1, а емкость – 256. Это значит, что до первого дополнительного выделения памяти в ivec можно вставить 256 элементов. При добавлении 256-го элемента вектор должен увеличиться: выделить память объемом в два раза больше текущей емкости, скопировать в нее старые элементы и освободить прежнюю память. Обратите внимание: чем больше и сложнее тип данных элементов, тем менее эффективен вектор в сравнении со списком. В таблице 6.1 показана зависимость начальной емкости вектора от используемого типа данных.

Итак, в реализации Rogue Wave при первой вставке выделяется точно или примерно 1024 байта. После каждого дополнительного выделения памяти емкость удваивается. Для типа данных, имеющего большой размер, емкость мала, и увеличение памяти с копированием старых элементов происходит часто, вызывая потерю эффективности. (Говоря о сложных классах, мы имеем в виду класс, обладающий копирующим конструктором и операцией присваивания.) В таблице ниже показано время в секундах, необходимое для вставки десяти миллионов элементов разного типа в список и в вектор. Таблица ниже показывает время, требуемое для вставки 10 000 элементов (вставка элементов большего размера оказалась слишком медленной).

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

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

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

Конечно, одним из решений может быть переход от вектора к списку, когда эффективность вектора становится слишком низкой. Другое, более предпочтительное решение состоит в том, чтобы хранить в векторе не объекты сложного класса, а указатели на них. Такая замена позволяет уменьшить затраты времени на 10 000 вставок с 6.70 секунд до 0.82 секунды. Почему? Емкость возросла с 1 до 256, что существенно снизило частоту перераспределения памяти. Кроме того, копирующий конструктор и деструктор не вызываются больше для каждого элемента при копировании прежнего содержимого вектора.

Функция reserve() позволяет программисту явно задать емкость контейнера . Например:

int main() {
   std::vector<std::string> svec;
   svec.reserve(32); // задает емкость равной 32
   // ...
}

svec получает емкость 32 при размере 0. Однако эксперименты показали, что любое изменение начальной емкости для вектора, у которого она по умолчанию отлична от 1, ведет к снижению производительности. Так, для векторов типа string и double увеличение емкости с помощью reserve() дало худшие показатели. С другой стороны, увеличение емкости для больших сложных типов дает значительный рост производительности, как показано в таблице 6.4.

Таблица 6.4. Время в секундах для вставки 10 000 элементов при различной емкости*

В нашей системе текстового поиска для хранения объектов типа string мы будем использовать вектор, не меняя его емкости по умолчанию. Наши измерения показали, что производительность вектора в данном случае лучше, чем у списка. Но прежде чем приступать к реализации, посмотрим, как определяется объект контейнерного типа.

Упражнение 6.2: Объясните разницу между размером и емкостью контейнера. Почему понятие емкости необходимо для контейнера, содержащего элементы в непрерывной области памяти, и не нужно для списка?

Упражнение 6.3: Почему большие сложные объекты удобнее хранить в контейнере в виде указателей на них, а для коллекции целых чисел применение указателей снижает эффективность?

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

(a) Целые числа (b) Указатели на большие сложные объекты (c) Большие сложные объекты

§ 1.4. Как определить последовательный контейнер?

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

#include <vector>
#include <list>
#include <deque>
#include <map>
#include <set>

Определение контейнера начинается именем его типа, за которым в угловых скобках следует тип данных его элементов . Например:

std::vector<std::string> svec;
std::list<int> ilist;

Переменная svec определяется как вектор, способный содержать элементы типа string, а ilist – как список с элементами типа int. Оба контейнера при таком определении пусты. Чтобы убедиться в этом, можно вызвать функцию-член empty():

if (svec.empty() != true)
   ; // что-то не так

Простейший метод вставки элементов – использование функции-члена push_back(), которая добавляет элементы в конец контейнера. Например:

std::string text_word;
while (std::cin >> text_word)
   svec.push_back(text_word);

Здесь строки из стандартного ввода считываются в переменную text_word, и затем копия каждой строки добавляется в контейнер svec с помощью push_back().

Список имеет функцию-член push_front(), которая добавляет элемент в его начало. Пусть есть следующий массив:

int ia[4] = { 0, 1, 2, 3 };

Использование push_back()

for (int ix=0; ix<4; ++ix)
   ilist.push_back(ia[ix]);

создаст последовательность 0, 1, 2, 3, а push_front()

for (int ix=0; ix<4; ++ix)
   ilist.push_front(ia[ix]);

создаст последовательность 3, 2, 1, 0.

Мы можем при создании явно указать размер массива – как константным, так и неконстантным выражением:

#include <list>
#include <vector>
#include <string>
extern int get_word_count(std::string file_name);
const int list_size = 64;
std::list<int> ilist(list_size);
std::vector<std::string> svec(get_word_count(std::string("Chimera")));

Каждый элемент контейнера инициализируется значением по умолчанию, соответствующим типу данных. Для int это 0. Для строкового типа вызывается конструктор по умолчанию класса string. Мы можем указать начальное значение всех элементов:

std::list<int> ilist(list_size, -1);
std::vector<std::string> svec(24, "pooh");

Разрешается не только задавать начальный размер контейнера, но и впоследствии изменять его с помощью функции-члена resize(). Например:

svec.resize(2 * svec.size());

Размер svec в этом примере удваивается. Каждый новый элемент получает значение по умолчанию. Если мы хотим инициализировать его каким-то другим значением, то оно указывается вторым параметром функции-члена resize():

// каждый новый элемент получает значение "piglet"
svec.resize(2 * svec.size(), "piglet");

Кстати, какова наиболее вероятная емкость svec при определении, если его начальный размер равен 24? Правильно, 24! В общем случае минимальная емкость вектора равна его текущему размеру. При удвоении размера емкость, как правило, тоже удваивается Мы можем инициализировать новый контейнер с помощью существующего. Например:

std::vector<std::string> svec2(svec);
std::list<int> ilist2(ilist) ;

Каждый контейнер поддерживает полный набор операций сравнения: равенство, неравенство, меньше, больше, меньше или равно, больше или равно. Сопоставляются попарно все элементы контейнера. Если они равны и размеры контейнеров одинаковы, то эти контейнеры равны; в противном случае – не равны. Результат операций больше или меньше определяется сравнением первых двух неравных элементов. Вот что печатает программа, сравнивающая пять векторов:

ivecl: 1 3 5 7 9 12
ivec2: 0 1 1 2 3 5 8 13
ivec3: 1 3 9
ivec4: 1 3 5 7
ivec5: 2 4

// первый неравный элемент: 1, О
// ivecl больше чем ivec2
ivecl < ivec2 //false
ivec2 < ivecl //true

// первый неравный элемент: 5, 9
ivecl < ivec3 //true
// все элементы равны, но ivec4 содержит меньше элементов
// следовательно, ivec4 меньше, чем ivecl
ivecl < ivec4 //false
// первый неравный элемент: 1, 2
ivecl < ivec5 //true
ivecl == ivecl //true
ivecl == ivec4 //false
ivecl != ivec4 //true
ivecl > ivec2 //true
ivec3 > ivecl //true
ivec5 > ivec2 //true

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

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

Все предопределенные типы данных, включая указатели и классы из стандартной библиотеки С++ удовлетворяют этим требованиям.

Упражнение 6.5: Объясните, что делает данная программа:

#include <string>
#include <vector>
#include <iostream>

int main() {
  std::vector<std::string> svec;
  svec.reserve(1024);
  std::string text_word;
  while (std::cin >> text_word)
    svec.push_back(text_word);
  svec.resize(svec.size()+svec.size()/2);
  // ...
}

Упражнение 6.6: Может ли емкость контейнера быть меньше его размера? Желательно ли, чтобы емкость была равна размеру: изначально или после вставки элемента? Почему?

Упражнение 6.7: Если программа из упражнения 6.5 прочитает 256 слов, то какова наиболее вероятная емкость контейнера после изменения размера? А если она считает 512 слов? 1000? 1048?

Упражнение 6.8: Какие из данных классов не могут храниться в векторе:

// (a)
class cl1 {
public:
   c11(int=0);
   bool operator==();
   bool operator!=();
   bool operator<=();
   bool operator<();
   // ...
};

// (b)
class c12 {
public:
   c12(int=0);
   bool operator!=();
   bool operator<=();
   // ...
};

// (с)
class c13 {
public:
   int ival;
};

// (d)
class c14 {
public:
   c14(int, int=0);
   bool operator==();
   bool operator!=();
   // ...
};

§ 1.5. Итераторы

Итератор предоставляет обобщенный способ перебора элементов любого контейнера – как последовательного, так и ассоциативного. Пусть iter является итератором для какого-либо контейнера. Тогда

++iter;

перемещает итератор так, что он указывает на следующий элемент контейнера, а

*iter;

разыменовывает итератор, возвращая элемент, на который он указывает.

Все контейнеры имеют функции-члены begin() и end().

• begin() возвращает итератор, указывающий на первый элемент контейнера.
• end() возвращает итератор, указывающий на элемент, следующий за последним в контейнере.

Чтобы перебрать все элементы контейнера, нужно написать:

for (iter = container. begin();
   iter != container.end(); ++iter)
   do_something_with_element(*iter);

Объявление итератора выглядит слишком сложным. Вот определение пары итераторов вектора типа string:

// std::vector<std::string> vec;
std::vector<std::string>::iterator iter = vec.begin();
std::vector<std::string>::iterator iter_end = vec.end();

В классе std::vector для определения iterator используется typedef. Синтаксис

std::vector<std::string>::iterator

ссылается на iterator, определенный с помощью typedef внутри класса std::vector, содержащего элементы типа string.

Для того чтобы напечатать все элементы вектора, нужно написать:

for(; iter != iter_end; ++iter)
     std::cout << *iter << '\n';

Здесь значением *iter выражения является, конечно, элемент вектора. В дополнение к типу iterator в каждом контейнере определен тип const_iterator, который необходим для навигации по контейнеру, объявленному как const. const_iterator позволяет только читать элементы контейнера:

#include <vector>
void even_odd(const std::vector<int> *pvec,
std::vector<int> *pvec_even,
std::vector<int> *pvec_odd)
{
   // const_iterator необходим для навигации по pvec
   std::vector<int>::const_iterator c_iter = pvec->begin();
   std::vector<int>::const_1terator c_iter_end = pvec->end();
   for (; c_iter != c_iter_end; ++c_iter)
   if (*c_iter % 2)
        pvec_even->push_back(*c_iter);
   else pvec_odd->push_back(*c_iter);
}

Что делать, если мы хотим просмотреть некоторое подмножество элементов, например взять каждый второй или третий элемент, или хотим начать с середины? Итераторы поддерживают адресную арифметику, а значит, мы можем прибавить некоторое число к итератору:

std::vector<int>::iterator iter = vec->begin()+vec.size()/2;

iter получает значение адреса элемента из середины вектора, а выражение

iter += 2;

сдвигает iter на два элемента. Арифметические действия с итераторами возможны только для контейнеров std::vector и deque. list не поддерживает адресную арифметику, поскольку его элементы не располагаются в непрерывной области памяти. Следующее выражение к списку неприменимо:

ilist.begin() + 2;

так как для перемещения на два элемента необходимо два раза перейти по адресу, содержащемуся в закрытом члене next. У классов std::vector и deque перемещение на два элемента означает прибавление 2 к указателю на текущий элемент. Объект контейнерного типа может быть инициализирован парой итераторов, обозначающих начало и конец последовательности копируемых в новый объект элементов. (Второй итератор должен указывать на элемент, следующий за последним копируемым.) Допустим, есть вектор:

#include <vector>
#include <string>
#include <iostream>

int main()
{
  std::vector<std::string> svec;
  string intext;
  while (std::cin >> intext)
    svec.push_back(intext);
  // обработать svec ...
}

Вот как можно определить новые векторы, инициализируя их элементами первого вектора:

int main() {
   std::vector<std::string> svec;
   // ...
   // инициализация svec2 всеми элементами svec
   std::vector<std::string> svec2(svec.begin(), svec.end());

   // инициализация svec3 первой половиной svec
   std::vector<std::string>::iterator it =
   svec.begin() + svec.size()/2;
   std::vector<std::string> svec3 (svec.begin(), it);
   // ...
}

Использование специального типа istream_iterator упрощает чтение элементов из входного потока в svec:

#include <vector>
#include <string>
#include <iterator>

int main() {
   // привязка istream_iterator к стандартному вводу
   istream_iterator<std::string> infile(std::cin);

   // istream_iterator, отмечающий конец потока
   istream_iterator<std::string> eos;

   // инициализация svec элементами, считываемыми из std::cin;
   std::vector<std::string> svec(infile, eos);
   // ...
}

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

#include <string>
std::string words[4] = {
   "stately", "plump", "buck", "mulligan"
};

Мы можем инициализировать вектор с помощью указателей на первый элемент массива и на элемент, следующий за последним:

std::vector<std::string> vwords(words, words+4);

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

int ia[6] = { 0, 1, 2, 3, 4, 5 };
std::list<int> ilist(ia, ia+6);

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

Упражнение 6.9: Какие ошибки допущены при использовании итераторов:

const std::vector<int> ivec;
std::vector<std::string> svec;
std::list<int> ilist;

(a) std::vector<int>::iterator it = ivec.begin();
(b) std::list<int>::iterator it = ilist.begin()+2;
(c) std::vector<std::string>::iterator it = &svec[0];
(d) for (std::vector<std::string>::iterator it = svec.begin(); it != 0; ++it)
    // ...

Упражнение 6.10: Найдите ошибки в использовании итераторов:

int ia[7] = { 0, 1, 1, 2, 3, 5, 8 };
std::string sa[6] = {
   "Fort Sumter", "Manassas", "Perryville", "Vicksburg",
   "Meridian", "Chancellorsvine" };

(a) std::vector<std::string> svec(sa, &sa[6]);
(b) std::list<int> ilist(ia+4, ia+6);
(c) std::list<int> ilist2(ilist.begin(), ilist.begin()+2);
(d) std::vector<int> ivec(&ia[0], ia+8);
(e) std::list<std::string> slist(sa+6, sa);
(f) std::vector<std::string> svec2(sa, sa+6);

§ 1.6. Операции с последовательными контейнерами

Функция-член push_back() позволяет добавить единственный элемент в конец контейнера. Но как вставить элемент в произвольную позицию? А целую последовательность элементов? Для этих случаев существуют более общие операции. Например, для вставки элемента в начало контейнера можно использовать:

std::vector<std::string> svec;
std::list<std::string> slist;
std::string spouse("Beth");

slist.insert(slist.begin(), spouse);
svec.insert(svec.begin(), spouse);

Первый параметр функции-члена insert() (итератор, адресующий некоторый элемент контейнера) задает позицию, а второй – вставляемое перед этой позицией значение. В примере выше элемент добавляется в начало контейнера. А так можно реализовать вставку в произвольную позицию:

std::string son("Danny");
std::list<std::string>::iterator iter;
iter = find(slist.begin(), slist.end(), son);
slist.insert(iter, spouse);

Здесь find() возвращает позицию элемента в контейнере, если элемент найден, либо итератор end(), если ничего не найдено. (Мы вернемся к функции find() в конце следующего раздела.) Как можно догадаться, push_back() эквивалентен следующей записи:

// эквивалентный вызов: slist.push_back(value);
slist.insert(slist.end(), value);

Вторая форма функции-члена insert() позволяет вставить указанное количество одинаковых элементов, начиная с определенной позиции. Например, если мы хотим добавить десять элементов Anna в начало вектора, то должны написать:

std::vector<std::string> svec;
std::string anna("Anna");
svec.insert(svec.begin(), 10, anna);

insert() имеет и третью форму, помогающую вставить в контейнер несколько элементов. Допустим, имеется следующий массив:

std::string sarray[4] = { "quasi", "simba", "frollo", "scar" };

Мы можем добавить все его элементы или только некоторый диапазон в наш вектор строк:

svec.insert(svec.begin(), sarray, sarray+4);
svec.insert(svec.begin() + svec.size()/2,
sarray+2, sarray+4);

Такой диапазон отмечается и с помощью пары итераторов

// вставляем элементы svec в середину svec_two
svec_two.insert(svec_two.begin() + svec_two.size()/2,
svec.begin(), svec.end());

или любого контейнера, содержащего строки:

std::list<std::string> slist;
// ...
// вставляем элементы svec
// перед элементом, содержащим stringVal
std::list<std::string>::iterator iter = std::find(slist.begin(), slist.end(), stringVal);
slist.insert(iter, svec.begin(), svec.end());

6.6.1. Удаление

В общем случае удаление осуществляется двумя формами функции-члена erase(). Первая форма удаляет единственный элемент, вторая – диапазон, отмеченный парой итераторов. Для последнего элемента можно воспользоваться функцией-членом pop_back(). При вызове erase() параметром является итератор, указывающий на нужный элемент. В следующем фрагменте кода мы воспользуемся обобщенным алгоритмом find() для нахождения элемента и, если он найден, передадим его адрес функции-члену erase().

std::string searchValue("Quasimodo");
std::list<std::string>::iterator iter = std::find(slist.begin(), slist.end(), searchValue);
if (iter != slist.end())
   slist.erase(iter);

Для удаления всех элементов контейнера или некоторого диапазона можно написать следующее:

// удаляем все элементы контейнера
slist.erase(slist.begin(), slist.end());

// удаляем элементы, помеченные итераторами
std::list<std::string>::iterator first, last;

first = find(slist.begin(), slist.end(), vail);
last = find(slist.begin(), slist.end(), va12);
// ... проверка first и last
slist.erase(first, last);

Парной по отношению к push_back() является функция-член pop_back(), удаляющая из контейнера последний элемент, не возвращая его значения:

std::vector<std::string>::iterator iter = buffer.begin();
for (; iter != buffer.end(), iter++) {
   slist.push_back(*iter);
   if (! do_something(slist))
      slist.pop_back();
}

6.6.2. Присваивание и обмен

Что происходит, если мы присваиваем один контейнер другому? Оператор присваивания копирует элементы из контейнера, стоящего справа, в контейнер, стоящий слева от знака равенства. А если эти контейнеры имеют разный размер? Например:

// svecl содержит 10 элементов
// svec2 содержит 24 элемента
// после присваивания оба содержат по 24 элемента
svecl = svec2;

Контейнер-адресат (svec1) теперь содержит столько же элементов, сколько контейнер-источник (svec2). 10 элементов, изначально содержавшихся в svec1, удаляются (для каждого из них вызывается деструктор класса string). Функция обмена swap() может рассматриваться как дополнение к операции присваивания. Когда мы пишем:

svecl.swap(svec2);

svec1 после вызова функции содержит 24 элемента, которые он получил бы в результате присваивания:

svecl = svec2;

но зато теперь svec2 получает 10 элементов, ранее находившихся в svec1. Контейнеры обмениваются своим содержимым.

6.6.3. Обобщенные алгоритмы

Операции, описанные в предыдущих разделах, составляют набор, поддерживаемый непосредственно контейнерами std::vector и deque. Согласитесь, что это весьма небогатый интерфейс и ему явно не хватает базовых операций find(), sort(), merge() и т.д. Планировалось вынести общие для всех контейнеров операции в набор обобщенных алгоритмов, которые могут применяться ко всем контейнерным типам, а также к массивам встроенных типов. (Обобщенные алгоритмы описываются в главе 12 и в Приложении.) Эти алгоритмы связываются с определенным типом контейнера с помощью передачи им в качестве параметров пары соответствующих итераторов. Вот как выглядят вызовы алгоритма find() для списка, вектора и массива разных типов:

#include <list>
#include <vector>

int ia[6] = { 0, 1, 2, 3, 4, 5 };
std::vector<std::string> svec;
std::list<double> dtist;

// соответствующий заголовочный файл
#include <algorithm>
std::vector<std::string>::iterator viter;
std::list<double>::iterator liter;
int *pia;

// find() возвращает итератор на найденный элемент
// для массива возвращается указатель ...
pia = std::find(&ia[0], &ia[6], some_int_value);
liter = std::find(dlist.begin(), dlist.end(), some_double_value);
viter = std::find(svec.begin(), svec.end(), some_string_value);

Контейнер list поддерживает дополнительные операции, такие, как sort() и merge(), поскольку в нем не реализован произвольный доступ к элементам. (Эти операции описаны в разделе 12.6.) Теперь вернемся к нашей поисковой системе.

Упражнение 6.11

Напишите программу, в которой определены следующие объекты:

int ia[] = { 1, 5, 34 };
int ia2[] = { 1, 2, 3 };
int ia3[] = { 6, 13, 21, 29, 38, 55, 67, 89 };
std::vector<int> ivec;

Используя различные операции вставки и подходящие значения ia, ia2 и ia3, модифицируйте вектор ivec так, чтобы он содержал последовательность:

{ 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 }

Упражнение 6.12

Напишите программу, определяющую данные объекты:

int ia[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89 };
std::list<int> ilist(ia, ia+11);

Используя функцию-член erase() с одним параметром, удалите из ilist все нечетные элементы.

§ 1.7. Читаем текстовый файл

Первая наша задача – прочитать текстовый файл, в котором будет производиться поиск. Нам нужно сохранить следующую информацию: само слово, номер строки и позицию в строке, где слово встречается. Как получить одну строку текста? Стандартная библиотека предоставляет для этого функцию getline():

std::istream& getline(std::istream& is, std::string str, char delimiter);

getline()берет из входного потока все символы, включая пробелы, и помещает их в объект типа string, до тех пор пока не встретится символ delimiter, не будет достигнут конец файла или количество полученных символов не станет равным величине, возвращаемой функцией-членом max_size()класса string. Мы будем помещать каждую такую строку в вектор. Мы вынесли код, читающий файл, в функцию, названную retrieve_text(). В объекте типа pair дополнительно сохраняется размер и номер самой длинной строки. (Полный текст программы приводится в разделе 6.14.) Вот реализация функции ввода файла:

// возвращаемое значение - указатель на строковый вектор
std::vector<std::string>* retrieve_text() {
   std::string file_name;
   std::cout << "please enter file name: ";
   std::cin >> file_name;

   // откроем файл для ввода ...
   ifstream 1nfile(file_name.c_str(), ios::in);
   if (! infile) {
      std::cerr << "oops! unable to open file "
         << file_name << " -- bailing out!\n";
      exit(-1);
   }
   else std::cout << '\n';

   std::vector<std::string> *1ines_of_text = new std::vector<std::string>;
   std::string textime;

   typedef std::pair<std::string::size_type, int> stats;
   stats maxline;
   int linenum = 0;

   while (getline(infile, textline, '\n')) {
      std::cout << "line read: " << textline << '\n';
      if (maxline.first < textline.size()) {
         maxline.first = textline.size() ;
         maxline.second = linenum;
      }
      lines_of_text->push_back(textline);
      linenum++;
   }
   return lines_of_text;
}

Вот как выглядит вывод программы (размер страницы книги недостаточен, чтобы расположить напечатанные строки во всю длину, поэтому мы сделали в тексте отступы, показывающие, где реально заканчивалась строка):

please enter file name: a1ice_emma

line read: Alice Emma has long flowing red hair. Her Daddy says
line read: when the wind blows through her hair, it looks
almost alive,
line read: like a fiery bird in flight. A beautiful fiery bird,
he tells her,
line read: magical but untamed. "Daddy, shush, there is no such
thing, "
line read: she tells him, at the same time wanting him to tell
her more.
line read: Shyly, she asks, "I mean. Daddy, is there?"
number of lines: 6
maximum length: 66
longest line: like a fiery bird in flight. A beautiful fiery
bird, he tells her,

После того как все строки текста сохранены, нужно разбить их на слова. Сначала мы отбросим знаки препинания. Например, возьмем строку из части Anna Livia Plurrabelle романа Finnegans Wake.

"For every tale there's a telling,
and that's the he and she of it."

В приведенном фрагменте есть следующие знаки препинания:

"For
there's
telling,
that's
it."

А хотелось бы получить:

For
there
telling
that
it

Можно возразить, что

there's

должно превратиться в

there is

но мы-то движемся в другом направлении: следующий шаг – это отбрасывание семантически нейтральных слов, таких, как is, that, and, it и т.д. Так что для данной строчки из Finnegans Wake только два слова являются значимыми: tale и telling, и только по этим словам будет выполняться поиск. (Мы реализуем набор стоп-слов с помощью контейнерного типа std::set, который подробно рассматривается в следующем разделе.) После удаления знаков препинания нам необходимо превратить все прописные буквы в строчные, чтобы избежать проблем с поиском в таких, например, строках:

Home is where the heart is.
A home is where they have to let you in.

Несомненно, запрос слова home должен найти обе строки. Мы должны также обеспечить минимальную поддержку учета словоформ: отбрасывать окончания слов, чтобы слова dog и dogs, love, loving и loved рассматривались системой как одинаковые. В следующем разделе мы вернемся к описанию стандартного класса string и рассмотрим многочисленные операции над строками, которые он поддерживает, в контексте дальнейшей разработки нашей поисковой системы.

§ 1.8. Выделяем слова в строке

Нашей первой задачей является разбиение строки на слова. Мы будем вычленять слова, находя разделяющие их пробелы с помощью функции find(). Например, в строке

Alice Emma has long flowing red hair.

насчитывается шесть пробелов, следовательно, эта строка содержит семь слов. Класс string имеет несколько функций поиска. find() – наиболее простая из них. Она ищет образец, заданный как параметр, и возвращает позицию его первого символа в строке, если он найден, или специальное значение string::npos в противном случае. Например:

#include <string>
#include <iostream>

int main() {
   std::string name("AnnaBelle");
   int pos = name.find("Anna");
   if (pos == string::npos)
      std::cout << "Anna не найдено!\n";
   else std::cout << "Anna найдено в позиции: " << pos << std::endl;
}

Хотя позиция подстроки почти всегда имеет тип int, более правильное и переносимое объявление типа результата, возвращаемого find(), таково:

std::string::size_type

Например:

std::string::size_type pos = name.find("Anna");

Функция find() делает не совсем то, что нам надо. Требуемая функциональность обеспечивается функцией find_first_of(), которая возвращает позицию первого символа, соответствующего одному из заданных в строке-параметре. Вот как найти первый символ, являющийся цифрой:

#include <string>
#include <iostream>

int main() {
   std::string numerics("0123456789");
   std::string name("r2d2");
   std::string::size_type pos = name.find_first_of(numerics);
   std::cout << "найдена цифра в позиции: "
      << pos << "\tэлемент равен "
      << name[pos] << std::endl;
}

В этом примере pos получает значение 1 (напоминаем, что символы строки нумеруются с 0). Но нам нужно найти все вхождения символа, а не только первое. Такая возможность реализуется передачей функции find_first_of() второго параметра, указывающего позицию, с которой начать поиск. Изменим предыдущий пример. Можете ли вы сказать, что в нем все еще не вполне удовлетворительно?

#include <string>
#include <iostream>
int main() {
   std::string numerics("0123456789");
   std::string name("r2d2");
   std::string::size_type pos = 0;

   // где-то здесь ошибка!
   while ((pos = name.find_first_of(numerics, pos)) != std::string::npos)
      std::cout << "найдена цифра в позиции: "
         << pos << "\tэлемент равен "
         << name[pos] << std::endl;
}

В начале цикла pos равно 0, поэтому поиск идет с начала строки. Первое вхождение обнаружено в позиции 1. Поскольку найденное значение не совпадает с string::npos, выполнение цикла продолжается. Для второго вызова find_first_of()значение pos равно 1. Поиск начнется с 1-й позиции. Вот ошибка! Функция find_first_of() снова найдет цифру в первой позиции, и снова, и снова... Получился бесконечный цикл. Нам необходимо увеличивать pos на 1 в конце каждой итерации:

// исправленная версия цикла
while ((pos = name.find_first_of(numerics, pos))
         != string::npos)
{
   std::cout << "найдена цифра в позиции: "
        << pos << "\tэлемент равен "
        << name[pos] << std::endl;
   // сдвинуться на 1 символ
   ++pos;
}

Чтобы найти все пустые символы (к которым, помимо пробела, относятся символы табуляции и перевода строки), нужно заменить строку numerics в этом примере строкой, содержащей все эти символы. Если же мы уверены, что используется только символ пробела и никаких других, то можем явно задать его в качестве параметра функции:

// фрагмент программы
while ((pos = textline.find_first_of(' ', pos))
      != string::npos)
// ...

Чтобы узнать длину слова, введем еще одну переменную:

// фрагмент программы
// pos: позиция на 1 большая конца слова
// prev_pos: позиция начала слова
string::size_type pos = 0, prev_pos = 0;
while ((pos = textline.find_first_of(' ', pos))
      != string::npos)
{
  // ...

  // запомнить позицию начала слова

  prev_pos = ++pos;
}

На каждой итерации prev_pos указывает позицию начала слова, а pos – позицию следующего символа после его конца. Соответственно, длина слова равна: pos - prev_pos; // длина слова После того как мы выделили слово, необходимо поместить его в строковый вектор. Это можно сделать, копируя в цикле символы из textline с позиции prev_pos до pos -1. Функция substr() сделает это за нас:

// фрагмент программы
std::vector<std::string> words;
while ((pos = textline.find_first_of(' ', pos)) != std::string::npos) {
   words.push_back(textline.substr(prev_pos, pos-prev_pos));
   prev_pos = ++pos;
}

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

seaspawn and seawrack

После каждого из первых двух слов поставлен пробел. Два вызова функции find_first_of() вернут позиции этих пробелов. Третий же вызов вернет string::npos, и цикл закончится. Таким образом, последнее слово останется необработанным. Вот полный текст функции, названной нами separate_words(). Помимо сохранения слов в векторе строк, она вычисляет координаты каждого слова – номер строки и колонки (нам эта информация потребуется впоследствии).

typedef std::pair<short, short> location;
typedef std::vector<location> loc;
typedef std::vector<std::string> text;
typedef std::pair<text* ,loc*> text_loc;
text_loc*
separate_words(const std::vector<std::string> *text_file)
{
   // words: содержит набор слов
   // locations: содержит информацию о строке и позиции
   // каждого слова
   std::vector<std::string> *words = new std::vector<std::string>;
   std::vector<location> * locations = new std::vector<location>;

   short line_pos = 0; // текущий номер строки
   // iterate through each line of text
   for (; line_pos < text_file->size(); ++line_pos)
      // textline: обрабатываемая строка
      // word_pos: позиция в строке
      short word_pos = 0;
      std::string textline = (*text_file) [line_pos];

      std::string::size_type pos = 0, prev_pos = 0;

      while ((pos = textline.find_first_of(' ', pos)) != std::string::npos) {
         // сохраним слово
         words->push_back(textline.substr(prev_pos, pos - prev_pos));

         // сохраним информацию о его строке и позиции
         locations->push_back(std::make_pair(line_pos, word_pos));

         // сместим позицию для следующей итерации
         ++word_pos; prev_pos = ++pos;
      }

      // обработаем последнее слово
      words->push_back(textline.substr(prev_pos, pos - prev_pos));

      locations->push_back(std::make_pair(line_pos, word_pos));
   }
  return new text_loc(words, locations);
}

  Теперь функция main()выглядит следующим образом:

int main()
{
   std::vector<std::string> *text_file = retrieve_text();
   text_loc *text_locations = separate_words(text_file);
   // ...
}

Вот часть распечатки, выданной тестовой версией separate_words():

textline: Alice Emma has long flowing red hair. Her Daddy
         says
eol: 52 pos: 5 line: 0 word: 0 substring: Alice
eol: 52 pos: 10 line: 0 word: 1 substring: Emma
eol: 52 pos: 14 line: 0 word: 2 substring: has
eol: 52 pos: 19 line: 0 word: 3 substring: long
eol: 52 pos: 27 line: 0 word: 4 substring: flowing
eol: 52 pos: 31 line: 0 word: 5 substring: red
eol: 52 pos: 37 line: 0 word: 6 substring: hair.
eol: 52 pos: 41 line: 0 word: 7 substring: Her
eol: 52 pos: 47 line: 0 word: 8 substring: Daddy
last word on line substring: says

...

textline: magical but untamed. "Daddy, shush, there is no
         such thing,"
eol: 60 pos: 7 line: 3 word: 0 substring: magical
eol: 60 pos: 11 line: 3 word: 1 substring: but
eol: 60 pos: 20 line: 3 word: 2 substring: untamed
eol: 60 pos: 28 line: 3 word: 3 substring: "Daddy,
eol: 60 pos: 35 line: 3 word: 4 substring: shush,
eol: 60 pos: 41 line: 3 word: 5 substring: there
eol: 60 pos: 44 line: 3 word: 6 substring: is
eol: 60 pos: 47 line: 3 word: 7 substring: no
eol: 60 pos: 52 line: 3 word: 8 substring: such
last word on line substring: thing,":

...

textline: Shy1y, she asks, "I mean, Daddy: is there?"
eol: 43 pos: 6 line: 5 word: 0 substring: Shyly,
eol: 43 pos: 10 line: 5 word: 1 substring: she
eol: 43 pos: 16 line: 5 word: 2 substring: asks,
eol: 43 pos: 19 line: 5 word: 3 substring: "I
eol: 43 pos: 25 line: 5 word: 4 substring: mean,
eol: 43 pos: 32 line: 5 word: 5 substring: Daddy,
eol: 43 pos: 35 line: 5 word: 6 substring: is
last word on line substring: there?":

Прежде чем продолжить реализацию поисковой системы, вкратце рассмотрим оставшиеся функции-члены класса string, предназначенные для поиска. Функция rfind() ищет последнее, т.е. самое правое, вхождение указанной подстроки:

std::string river("Mississippi");
std::string::size_type first_pos = river.find("is");
std::string::size_type 1ast_pos = river.rfind("is");

find() вернет 1, указывая позицию первого вхождения подстроки "is", а rfind() – 4 (позиция последнего вхождения "is"). find_first_not_of() ищет первый символ, не содержащийся в строке, переданной как параметр. Например, чтобы найти первый символ, не являющийся цифрой, можно написать:

std::string elems("0123456789");
std::string dept_code("03714p3");

// возвращается позиция символа 'p'
std::string::size_type pos = dept_code.find_first_not_of(elems) ;

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

Упражнение 6.13

Напишите программу, которая ищет в строке

"ab2c3d7R4E6"

цифры, а затем буквы, используя сначала find_first_of(), а потом find_first_not_of().

Упражнение 6.14

Напишите программу, которая подсчитывает все слова и определяет самое длинное и самое короткое из них в строке sentence:

string linel = "We were her pride of 10 she named us --";
string line2 = "Benjamin, Phoenix, the Prodigal"
string line3 = "and perspicacious pacific Suzanne";
string sentence = linel + line2 + line3;

Если несколько слов имеют длину, равную максимальной или минимальной, учтите их все.

§ 1.9. Обрабатываем знаки препинания

После того как мы разбили каждую строку на слова, необходимо избавиться от знаков препинания. Пока из строки

magical but untamed. "Daddy, shush, there is no such thing,"

у нас получился такой набор слов:

magical
but
untamed.
"Daddy,
shush,
there
is
no
such
thing,"

Как нам теперь удалить ненужные знаки препинания? Для начала определим строку, содержащую все символы, которые мы хотим удалить:

std::string filt_elems("\",.;:!?)(\\/");

(Обратная косая черта указывает на то, что следующий за ней символ должен в данном контексте восприниматься буквально, а не как специальная величина. Так, \" обозначает символ двойной кавычки, а не конец строки, а \\ – символ обратной косой черты.) Теперь можно применить функцию-член find_first_of() для поиска всех вхождений нежелательных символов:

while ((pos = word.find_first_of(filt_elems, pos))
      != string::npos)

Найденный символ удаляется с помощью функции-члена erase():

word.erase(pos,1);

Первый аргумент этой функции означает позицию подстроки, а второй – ее длину. Мы удаляем один символ, находящийся в позиции pos. Второй аргумент является необязательным; если его опустить, будут удалены все символы от pos до конца строки. Вот полный текст функции filter_text(). Она имеет два параметра: указатель на вектор строк, содержащий текст, и строку с символами, которые нужно убрать.

void
filter_text(std::vector<std::string> *words, string filter) {
   std::vector<std::string>::iterator iter = words->begin();
   std::vector<std::string>::iterator iter_end = words->end();

   // Если filter не задан, зададим его сами
   if (! filter.size())
      filter.insert(0, "\".,");

   while (iter != iter_end) {
      std::string::size_type pos = 0;

      // удалим каждый найденный элемент
      while ((pos = (*iter).find_first_of(filter, pos))
            != string::npos)
         (*iter).erase(pos,1);
      iter++;
   }
}

Почему мы не увеличиваем значение pos на каждой итерации? Что было бы, если бы мы написали:

while ((pos = (*iter).find_first_of(filter, pos)) != string::npos) {
   (*iter).erase(pos,1);
   ++ pos; // неправильно...
}

Возьмем строку

thing,"

На первой итерации pos получит значение 5 , т.е. позиции, в которой находится запятая. После удаления запятой строка примет вид

thing"

Теперь в 5-й позиции стоит двойная кавычка. Если мы увеличим значение pos, то пропустим этот символ. Так мы будем вызывать функцию filter_text():

std::string filt_elems("\",.;:!?)(\\/");
filter_text(text_locations->first, filt_elems);

А вот часть распечатки, сделанной тестовой версией filter_text():

filter_text: untamed.
found! : pos: 7.
after: untamed

filter_text: "Daddy,
found! : pos: 0.
after: Daddy,
found! : pos: 5.
after: Daddy

filter_text: thing,"
found! : pos: 5.
after: thing"
found! : pos: 5.
after: thing

filter_text: "I
found! : pos: 0.
after: I

filter_text: Daddy,
found! : pos: 5.
after: Daddy

filter_text: there?"
found! : pos: 5.
after: there"
found! : pos: 5.
after: there

Упражнение 6.15

Напишите программу, которая удаляет все символы, кроме STL из строки:

"/.+(STL).$1/"

используя сначала erase(pos,count), а затем erase(iter,iter).

Упражнение 6.16

Напишите программу, которая с помощью разных функций вставки из строк

std::string sentence("kind of");
std::string s1 ("whistle")
std::string s2 ("pixie")

составит предложение

"A whistling-dixie kind of walk"

§ 1.10. Приводим слова к стандартной форме

Одной из проблем при разработке текстовых поисковых систем является необходимость распознавать слова в различных словоформах, такие, как cry, cries и cried, baby и babies, и, что гораздо проще, написанные заглавными и строчными буквами, например home и Home. Первая задача, распознавание словоформ, слишком сложна, поэтому мы приведем здесь ее заведомо неполное решение. Сначала заменим все прописные буквы строчными:

void strip_caps(std::vector<std::string> *words) {
   std::vector<std::string>::iterator iter=words->begin() ;
   std::vector<std::string>::iterator iter_end=words->end() ;

   string caps("ABCDEFGHIJKLMNOPQRSTUVWXYZ");

   while (iter != iter_end) {
      std::string::size_type pos = 0;
      while ((pos = (*iter).find_first_of(caps, pos))
            != string::npos)
         (*iter)[pos] = to1ower((*iter)[pos]);
      ++iter;
   }
}

Функция

to1ower((*iter)[pos]);

входит в стандартную библиотеку С. Она заменяет прописную букву соответствующей ей строчной. Для использования tolower() необходимо включить заголовочный файл:

#include <ctype.h>

(В этом файле объявлены и другие функции, такие, как isalpha(), isdigit(), ispunct(), isspace(), toupper(). Полное описание этих функций см. [PLAUGER92]. Стандартная библиотека С++ включает класс ctype, который инкапсулирует всю функциональность стандартной библиотеки Си, а также набор функций, не являющихся членами, например toupper(), tolower() и т.д. Для их использования нужно включить заголовочный файл

#include <locale>

Однако наша реализация компилятора еще не поддерживала класс ctype, и нам пришлось использовать стандартную библиотеку Си.) Проблема словоформ слишком сложна для того, чтобы пытаться решить ее в общем виде. Но даже самый примитивный вариант способен значительно улучшить работу нашей поисковой системы. Все, что мы сделаем в данном направлении, – удалим букву 's' на концах слов:

void suffix_text(std::vector<string,allocator> *words)
{
   std::vector<string,allocator>::iterator
         iter = words->begin(),
         iter_end = words->end();

   while (iter != iter_end) {
      // оставим слова короче трех букв как есть
      if ((*iter).size() <= 3)
         { ++iter; continue; }
      if ((*iter)[(*iter).size()-1] == 's')
         suffix_s(*iter);

      // здесь мы могли бы обработать суффиксы
      // ed, ing, 1y

      ++iter;
   }
}

Слова из трех и менее букв мы пропускаем. Это позволяет оставить без изменения, например, has, its, is и т.д., однако слова tv и tvs мы не сможем распознать как одинаковые. Если слово кончается на "ies", как babies и cries, необходимо заменить "ies" на "y":

std::string::size_type pos() = word.size()-3;
std::string ies("ies");
if (! word.compare(pos3, 3, ies)) {
   word.replace(pos3, 3, 1, 'у');
   return;
}

compare() возвращает 0, если две строки равны. Первый аргумент, pos3, обозначает начальную позицию, второй – длину сравниваемой подстроки (в нашем случае 3). Третий аргумент, ies, – строка-эталон. (На самом деле существует шесть вариантов функции compare(). Остальные мы покажем в следующем разделе.) replace() заменяет подстроку набором символов. В данном случае мы заменяем подстроку "ies" длиной в 3 символа единичным символом 'y'. (Имеется десять перегруженных вариантов функции replace(). В следующем разделе мы коснемся остальных вариантов.) Если слово заканчивается на "ses", как promises или purposes, нужно удалить суффикс "es" :

string ses("ses");
if (! word.compare(pos3, 3, ses)) {
   word.erase(pos3+l, 2);
   return;
}

Если слово кончается на "ous", как oblivious, fulvous, cretaceous, или на "is", как genesis, mimesis, hepatitis, мы не будем изменять его. (Наша система несовершенна. Например, в слове kiwis надо убрать последнее 's'.) Пропустим и слова, оканчивающиеся на "ius" (genius) или на "ss" (hiss, lateness, less). Нам поможет вторая форма функции compare():

std::string::size_type spos = 0;
std::string::size_type pos3 = word.size()-3;

// "ous", "ss", "is", "ius"
string suffixes("oussisius");

if (! word.compare(pos3, 3, suffixes, spos, 3) || // ous
     ! word.compare(pos3, 3, suffixes, spos+6, 3) || // ius
     ! word.compare(pos3+l, 2, suffixes, spos+2, 2) || // ss
     ! word.compare(pos3+l, 2, suffixes, spos+4, 2)) // is
     return;

В противном случае удалим последнее 's':

// удалим последнее 's'
word.erase(pos3+2);

Имена собственные, например Pythagoras, Brahms, Burne-Jones, не подпадают под общие правила. Этот случай мы оставим как упражнение для читателя, когда будем рассказывать об ассоциативных контейнерах.

Но прежде чем перейти к ним, рассмотрим оставшиеся строковые операции.

Упражнение 6.17

Наша программа не умеет обрабатывать суффиксы ed (surprised), ly (surprisingly) и ing (surprisingly). Реализуйте одну из функций для этого случая:

(a) suffix_ed() (b) suffix_ly() (c) suffix_ing()

§ 1.11. Дополнительные операции со строками

Вторая форма функции-члена erase() принимает в качестве параметров два итератора, ограничивающих удаляемую подстроку. Например, превратим

string name("AnnaLiviaPlurabelle");

в строку "Annabelle":

typedef std::string::size_type size_type;
size_type startPos = name.find('L')
size_type endPos = name.find_1ast_of('b');

name.erase(name.begin()+startPos,
name.begin()+endPos);

Символ, на который указывает второй итератор, не входит в удаляемую подстроку. Для третьей формы параметром является только один итератор; эта форма удаляет все символы, начиная с указанной позиции до конца строки. Например:

name.erase(name. begin()+4);

оставляет строку "Anna". Функция-член insert() позволяет вставить в заданную позицию строки другую строку или символ. Общая форма выглядит так:

string_object.insert(position, new_string);

position обозначает позицию, перед которой производится вставка. new_string может быть объектом класса string, C-строкой или символом:

std::string string_object("Missisippi");
std::string::size_type pos = string_object.find("isi");
string_object.insert(pos+1, 's');

Можно выделить для вставки подстроку из new_string:

std::string new_string("AnnaBelle Lee");
string_object += ' '; // добавим пробел

// найдем начальную и конечную позицию в new_string
pos = new_string.find('B');
std::string::size_type posEnd = new_string.find(' ');

string_object.insert(
   string_object.size(), // позиция вставки
   new_string, pos, // начало подстроки в new_string
   posEnd // конец подстроки new_string
)

string_object получает значение "Mississippi Belle". Если мы хотим вставить все символы new_string, начиная с pos, последний параметр нужно опустить. Пусть есть две строки:

std::string sl("Mississippi");
std::string s2("Annabelle");

Как получить третью строку со значением "Miss Anna"? Можно использовать функции-члены assign() и append():

std::string s3;
// скопируем первые 4 символа s1
s3.assign (s1, 4);
s3 теперь содержит значение "Miss".
// добавим пробел
s3 += ' ';

Теперь s3 содержит "Miss ".

// добавим 4 первых символа s2
s3.append(s2,4);
s3 получила значение "Miss Anna". То же самое можно сделать короче:
s3.assign(s1,4).append(' ').append(s2,4);

Другая форма функции-члена assign() имеет три параметра: второй обозначает позицию начала, а третий – длину. Позиции нумеруются с 0. Вот как, скажем, извлечь "belle" из "Annabelle":

std::string beauty;
// присвоим beauty значение "belle"
beauty.assign(s2, 4, 5);

Вместо этих параметров мы можем использовать пару итераторов:

// присвоим beauty значение "belle"
beauty.assign(s2, s2.begin()+4, s2.end());

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

std::string current_project("C++ Primer, 3rd Edition");
std::string pending_project("Fantasia 2000, Firebird segment");

Функция-член swap() позволяет обменять значения двух строк с помощью вызова

current_project.swap(pending_project);

Для строки

std::string first_novel("V");

операция взятия индекса

char ch = first_novel[1];

возвратит неопределенное значение: длина строки first_novel равна 1, и единственное правильное значение индекса – 0. Такая операция взятия индекса не обеспечивает проверку правильности параметра, но мы всегда можем сделать это сами с помощью функции-члена size():

int elem_count(const std::string& word, char elem) {
   int occurs = 0;
   // не надо больше проверять ix
   for (int ix=0; ix < word.size(); ++-ix)
      if (word[ix] == elem)
         ++occurs;
   return occurs;
}

Там, где это невозможно или нежелательно, например:

void mumble(const std::string& st, int index) {
   // возможна ошибка
   char ch = st[index];

   // ...
}

следует воспользоваться функцией at(), которая делает то же, что и операция взятия индекса, но с проверкой. Если индекс выходит за границу, возбуждается исключение out_of_range:

void mumble(const std::string& st, int index) {
   try {
      char ch = st.at(index);
      // ...
   }
   catch (std::out_of_range){...}
   // ...
}

Строки можно сравнивать лексикографически. Например:

std::string cobol_program_crash("abend");
std::string cplus_program_crash("abort");

Строка cobol_program_crash лексикографически меньше, чем cplus_program_crash: сопоставление производится по первому отличающемуся символу, а буква e в латинском алфавите идет раньше, чем o. Операция сравнения выполняется функцией-членом compare(). Вызов

sl.compare(s2);

возвращает одно из трех значений:

• если s1 больше, чем s2, то положительное;
• если s1 меньше, чем s2, то отрицательное;
• если s1 равно s2, то 0.

Например,

cobol_program_crash.compare(cplus_program_crash);

вернет отрицательное значение, а

cplus_program_crash.compare(cobol_program_crash);

положительное. Перегруженные операции сравнения (<, >, !=, ==, <=, >=) являются более компактной записью функции compare().

Шесть вариантов функции-члена compare() позволяют выделить сравниваемые подстроки в одном или обоих операндах. (Примеры вызовов приводились в предыдущем разделе.)

Функция-член replace() дает десять способов заменить одну подстроку на другую (их длины не обязаны совпадать). В двух основных формах replace() первые два аргумента задают заменяемую подстроку: в первом варианте в виде начальной позиции и длины, во втором – в виде пары итераторов на ее начало и конец. Вот пример первого варианта:

std::string sentence("An ADT provides both interface and implementation.");
std::string::size_type position = sentence.find_1ast_of('A');
std::string::size_type length = 3;

// заменяем ADT на Abstract Data Type
sentence.replace(position, length, "Abstract Data Type");

position представляет собой начальную позицию, а length – длину заменяемой подстроки. Третий аргумент является подставляемой строкой. Его можно задать несколькими способами. Допустим, как объект string:

std::string new_str("Abstract Data Type");
sentence.replace(position, length, new_str);

Следующий пример иллюстрирует выделение подстроки в new_str:

#include <string>
typedef std::string::size_type size_type;

// найдем позицию трех букв
size_type posA = new_str.find('A');
size_type posD = new_str.find('D');
size_type posT = new_str.find('T');

// нашли: заменим T на "Type"
sentence.replace(position+2, 1, new_str, posT, 4);

// нашли: заменим D на "Data "
sentence.replace(position+1, 1, new_str, posD, 5);

// нашли: заменим A на "Abstract "
sentence.replace(position, 1, new_str, posA, 9);

Еще один вариант позволяет заменить подстроку на один символ, повторенный заданное количество раз:

std::string hmm("Some celebrate Java as the successor to C++.");
std::string::size_type position = hmm.find('J');
// заменим Java на xxxx
hmm.repiace(position, 4, 'x', 4);

В данном примере используется указатель на символьный массив и длина вставляемой подстроки:

const char *lang = "EiffelAda95JavaModula3";
int index[] = { 0, 6, 11, 15, 22 };

std::string ahhem("C++ is the language for today's power programmers.");
ahhem.replace(0, 3, lang+index[1], index[2]-index[1]);

А здесь мы используем пару итераторов:

std::string sentence(
   "An ADT provides both interface and implementation.");

// указывает на 'A' в ADT
std::string::iterator start = sentence.begin()+3;

// заменяем ADT на Abstract Data Type
sentence.repiace(start, start+3, "Abstract Data Type");

Оставшиеся четыре варианта допускают задание заменяющей строки как объекта типа string, символа, повторяющегося N раз, пары итераторов и C-строки. Вот и все, что мы хотели сказать об операциях со строками. Для более полной информации обращайтесь к определению стандарта С++ [ISO-C++97].

Упражнение 6.18

Напишите программу, которая с помощью функций-членов assign() и append() из строк

std::string quote1("When lilacs last in the dooryard bloom'd");
std::string quote2("The child "is father of the man");

составит предложение The child is in the dooryard

Упражнение 6.19

Напишите функцию:

std::string generate_salutation(std::string generic1,
   std::string lastname,
   std::string generic2,
   std::string::size_type pos,
   int length);

которая в строке

std::string generic1("Dear Ms Daisy:");

заменяет Daisy и Ms (миссис). Вместо Daisy подставляется параметр lastname, а вместо Ms подстрока

std::string generic2("MrsMsMissPeople");

длины length, начинающаяся с pos. Например, вызов

std::string lastName("AnnaP");
string greetings =
      generate_salutation(generici, lastName, generic2, 5, 4);

вернет строку:

Dear Miss AnnaP:

§ 1.12. Строим отображение позиций слов

В этом разделе мы построим отображение (std::map), позволяющее для каждого уникального слова текста сохранить номера строк и колонок, в которых оно встречается. (В следующем разделе мы изучим ассоциативный контейнер std::set.) В общем случае контейнер std::set полезен, если мы хотим знать, содержится ли определенный элемент в некотором множестве, а std::map позволяет связать с каждым из них какую-либо величину. В std::map хранятся пары ключ/значение. Ключ играет роль индекса для доступа к ассоциированному с ним значению. В нашей программе каждое уникальное слово текста будет служить ключом, а значением станет вектор, содержащий пары (номер строки, номер колонки). Для доступа применяется оператор взятия индекса. Например:

string query("pickle");
std::vector<location> *locat;
// возвращается location<std::vector>*, ассоциированный с "pickle"
locat = text_map[query];

Ключом здесь является строка, а значение имеет тип location<std::vector>*. Для использования отображения необходимо включить соответствующий заголовочный файл:

#include <map>

Какие основные действия производятся над ассоциативными контейнерами? Их заполняют элементами или проверяют на наличие определенного элемента. В следующем подразделе мы покажем, как определить пару ключ/значение и как поместить такие пары в контейнер. Далее мы расскажем, как сформулировать запрос на поиск элемента и извлечь значение, если элемент существует.

6.12.1. Определение объекта std::map и заполнение его элементами

Чтобы определить объект класса std::map, мы должны указать, как минимум, типы ключа и значения. Например:

std::map<std::string, int> word_count;

Здесь задается объект word_count типа std::map, для которого ключом служит объект типа string, а ассоциированным с ним значением – объект типа int. Аналогично

class employee;
std::map<int,employee*> personnel;

определяет personnel как отображение ключа типа int (уникальный номер служащего) на указатель, адресующий объект класса employee. Для нашей поисковой системы полезно такое отображение:

typedef std::pair<short,short> location;
typedef std::vector<location> loc;
std::map<std::string,loc*> text_map;

Поскольку имевшийся в нашем распоряжении компилятор не поддерживал аргументы по умолчанию для параметров шаблона, нам пришлось написать более развернутое определение:

std::map<std::string, loc*, // ключ, значение
   std::less<std::string>, // оператор сравнения
   std::allocator> // распределитель памяти по умолчанию
text_map;

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

#include <map>
#include <string>
std::map<std::string, int> word_count;

word_count[std::string("Anna")] = 1;
word_count[std::string("Danny")] = 1;
word_count[std::string("Beth")] = 1;

// и так далее ...

Когда мы пишем:
word_count[std::string("Anna")] = 1;

на самом деле происходит следующее:

1. Безымянный временный объект типа string инициализируется значением "Anna" и передается оператору взятия индекса, определенному в классе std::map.
2. Производится поиск элемента с ключом "Anna" в массиве word_count. Такого элемента нет.
3. В word_count вставляется новая пара ключ/значение. Ключом является, естественно, строка "Anna". Значением – 0, а не 1.
4. После этого значению присваивается величина 1.

Если элемент отображения вставляется в отображение с помощью операции взятия индекса, то значением этого элемента становится значение по умолчанию для его типа данных. Для встроенных арифметических типов – 0. Следовательно, если инициализация отображения производится оператором взятия индекса, то каждый элемент сначала получает значение по умолчанию, а затем ему явно присваивается нужное значение. Если элементы являются объектами класса, у которого инициализация по умолчанию и присваивание значения требуют больших затрат времени, программа будет работать правильно, но недостаточно эффективно. Для вставки одного элемента предпочтительнее использовать следующий метод:

// предпочтительный метод вставки одного элемента
word_count.insert(
   std::map<std::string,i nt>::value_type(string("Anna"), 1)
);

В контейнере std::map определен тип value_type для представления хранимых в нем пар ключ/значение. Строки

std::map<std::string, int>::value_type(std::string("Anna"), 1)

создают объект pair, который затем непосредственно вставляется в std::map. Для удобства чтения можно использовать typedef:

typedef std::map<std::string, int>::value_type valType;

Теперь операция вставки выглядит проще:

word_count.insert(valType(std::string("Anna"), 1));

Чтобы вставить элементы из некоторого диапазона, можно использовать метод insert(), принимающий в качестве параметров два итератора. Например:

std::map<std::string, int> word_count;
// ... заполнить

std::map<std::string, int> word_count_two;

// скопируем все пары ключ/значение
word_count_two.insert(word_count.begin(),word_count.end());

Мы могли бы сделать то же самое, просто проинициализировав одно отображение другим:

// инициализируем копией всех пар ключ/значение
std::map<std::string, int> word_count_two(word_count);

Посмотрим, как можно построить отображение для хранения нашего текста. Функция separate_words(), описанная в разделе 6.8, создает два объекта: вектор строк, хранящий все слова текста, и вектор позиций, хранящий пары (номер строки, номер колонки) для каждого слова. Таким образом, первый объект дает нам множество значений ключей нашего отображения, а второй – множество ассоциированных с ними значений. separate_words() возвращает эти два вектора как объект типа pair, содержащий указатели на них. Сделаем эту пару аргументом функции build_word_map(), в результате которой будет получено соответствие между словами и позициями:

// typedef для удобства чтения
typedef std::pair<short, short> location;
typedef std::vector<location> loc;
typedef std::vector<std::string> text;
typedef std::pair<text*, loc*> text_loc;

extern std::map<std::string, loc* >*
build_word_map(const text_loc *text_locations);

Сначала выделим память для пустого объекта std::map и получим из аргумента-пары указатели на векторы:

std::map<std::string, loc*> *word_map = new std::map<std::string, loc* >;
std::vector<std::string> *text_words = text_locations->first;
std::vector<location> *text_locs = text_locations->second;

Теперь нам надо синхронно обойти оба вектора, учитывая два случая:

• слово встретилось впервые. Нужно поместить в std::map новую пару ключ/значение;
• слово встречается повторно. Нам нужно обновить вектор позиций, добавив дополнительную пару (номер строки, номер колонки).

Вот текст функции:

int elem_cnt = text_words->size();
for (int ix=0; ix < elem_cnt; ++ix) {
   std::string textword = (*text_words)[ix];

   // игнорируем слова короче трех букв
   // или присутствующие в списке стоп-слов
   if (textword.size() < 3 || exclusion_set.count(textword))
      continue;

   // определяем, занесено ли слово в отображение
   // если count() возвращает 0 - нет: добавим его
   if (! word_map->count((*text_words)[-ix])) {
      loc *ploc = new std::vector<location>;
      ploc->push_back((*text_locs) [ix]);
      word_map->insert(value_type((*text_words)[ix],ploc));
   }
   else
   // добавим дополнительные координаты
   (*word_map)[(*text_words)[ix]]->
            push_back((*text_locs)[ix]);
}

Синтаксически сложное выражение

(*word_map)[(*text_words)[ix]]->push_back((*text_locs)[ix]);

будет проще понять, если мы разложим его на составляющие:

// возьмем слово, которое надо обновить
std::string word = (*text_words) [ix];

// возьмем значение из вектора позиций
std::vector<location> *ploc = (*word_map) [word];

// возьмем позицию - пару координат
loc = (*text_locs)[ix];

// вставим новую позицию
ploc->push_back(loc);

Выражение все еще остается сложным, так как наши векторы представлены указателями. Поэтому вместо употребления оператора взятия индекса:

std::string word = text_words[ix]; // ошибка

мы вынуждены сначала разыменовать указатель на вектор:

std::string word = (*text_words) [ix]; // правильно

В конце концов build_word_map() возвращает построенное отображение:

return word_map;

Вот как выглядит вызов этой функции из main():

int main() {
   // считываем файл и выделяем слова
   std::vector<std::string> *text_file = retrieve_text();
   text_loc *text_locations = separate_words(text_file);
   // обработаем слова
   // ...
   // построим отображение слов на векторы позиций
   std::map<std::string, lос*, std::less<std::string>> *text_map = build_word_map(text_locatons);
   // ...
}

6.12.2. Поиск и извлечение элемента отображения

Оператор взятия индекса является простейшим способом извлечения элемента. Например:

// std::map<std::string,int> word_count;
int count = word_count["wrinkles"];

Однако этот способ работает так, как надо, только при условии, что запрашиваемый ключ действительно содержится в отображении. Иначе оператор взятия индекса поместит в отображение элемент с таким ключом. В данном случае в word_count занесется пара

std::string("wrinkles"), 0

Класс std::map предоставляет две операции для того, чтобы выяснить, содержится ли в нем определенное значение ключа.

• count(keyValue): функция-член count() возвращает количество элементов с данным ключом. (Для отображения оно равно только 0 или 1). Если count() вернула 1, мы можем смело использовать индексацию:

  int count = 0;
  if (word_count.count("wrinkles"))
       count = word_count["wrinkles"];
  

• find(keyValue): функция-член find() возвращает итератор, указывающий на элемент, если ключ найден, и итератор end() в противном случае. Например:

  int count = 0;
  std::map<string,int>::iterator it = word_count.find("wrinkles");
  if (it != word_count.end())
       count = (*it).second;
  

Значением итератора является указатель на объект pair, в котором first содержит ключ, а second – значение. (Мы вернемся к этому в следующем подразделе.)

6.12.3. Навигация по элементам отображения

После того как мы построили отображение, хотелось бы распечатать его содержимое. Мы можем сделать это, используя итератор, начальное и конечное значение которого получают с помощью функций-членов begin() и end(). Вот текст функции display_map_text():

void display_map_text(std::map<std::string, loc*> *text_map) {
   typedef std::map<std::string, loc*> tmap;
   tmap::iterator iter = text_map->begin(),
   iter_end = text_map->end();

   while (iter != iter_end) {
      std::cout << "word: " << (*iter).first << " (";
      int loc_cnt = 0;
      loc *text_locs = (*iter).second;
      loc::iterator liter = text_locs->begin(),
      liter_end = text_locs->end();

      while (liter != liter_end) {
         if (loc_cnt)
            std::cout << ',';
         else ++loc_cnt;
         std::cout << '(' << (*liter).first
              << ',' << (*liter).second << ')';

         ++liter;
      }
      std::cout << ")\n";
      ++iter;
   }
   std::cout << std::endl;
}

Если наше отображение не содержит элементов, данная функция не нужна. Проверить, пусто ли оно, можно с помощью функции-члена size():

if (text_map->size())
   display_map_text(text_map);

Но более простым способом, без подсчета элементов, будет вызов функции-члена empty():

if (! text_map->empty())
   display_map_text(text_map);

6.12.4. Словарь

Вот небольшая программа, иллюстрирующая построение отображения, поиск в нем и обход элементов. Здесь используются два отображения. Первое, необходимое для преобразования слов, содержит два элемента типа string. Ключом является слово, которое нуждается в специальной обработке, а значением – слово, заменяющее ключ. Для простоты мы задали пары ключ/значение непосредственно в тексте программы (вы можете модифицировать программу так, чтобы она читала их из стандартного ввода или из файла). Второе отображение используется для подсчета произведенных замен. Текст программы выглядит следующим образом:

#include <map>
#include <vector>
#include <iostream>
#include <string>

int main() {
   std::map<std::string, std::string> trans_map;
   typedef std::map<std::string, std::string>::value_type valType;

   // первое упрощение:
   // жестко заданный словарь
   trans_map.insert(va1Type("gratz", "grateful"));
   trans_map.insert(va1Type("'em", "them"));
   trans_map.insert(va1Type("cuz", "because"));
   trans_map.insert(va1Type("nah", "no"));
   trans_map.insert(va1Type("sez", "says"));
   trans_map.insert(va1Type("tanx", "thanks"));
   trans_map.insert(va1Type("wuz", "was"));
   trans_map.insert(va1Type("pos", "suppose"));

   // напечатаем словарь
   std::map<std::string, std::string>::iterator it;

   std::cout << "Наш словарь подстановок: \n\n";
   for (it = trans_map.begin(); it != trans_map.end(); ++it)
       std::cout << "ключ: " << (*it).first << "\t" << "значение: " << ("it).second << "\n";
   std::cout << "\n\n";

   // второе упрощение: жестко заданный текст
   std::string textarray[14]={ "nah", "I", "sez", "tanx",
         "cuz", "I", "wuz", "pos", "to", "not",
         "cuz", "I", "wuz", "gratz" };
   std::vector<std::string> text(textarray, textarray+14);
   std::vector<std::string>::iterator iter;

   // напечатаем текст
   std::cout << "Исходный вектор строк:\n\n";
   int cnt = 1;
   for (iter = text.begin(); iter != text.end(); ++iter, ++cnt)
      std::cout << *iter << (cnt % 8 ? " " : "\n");

   std::cout << "\n\n\n";

   // std::map для сбора статистики
   std::map<std::string, int> stats;
   typedef std::map<std::string, int>::value_type statsValType;
   // здесь происходит реальная работа
   for (iter=text.begin(); iter != text.end(); ++iter)
   if ((it = trans_map.find(*iter))
            != trans_map.end())
   {
      if (stats.count(*iter))
         stats [*iter] += 1;
      else stats.insert(statsVa1Type(*iter, 1));
      *iter = (*it).second;
   }

   // напечатаем преобразованный текст
   std::cout << "Преобразованный вектор строк:\n\n";
   cnt = 1;
   for (iter = text.begin(); iter != text.end(); ++iter, ++cnt)
       std::cout << *iter << (cnt % 8 ? " " : "\n");
           std::cout << "\n\n\n";

   // напечатаем статистику
   std::cout << "И напоследок статистика:\n\n";
   std::map<std::string, int, std::less<std::string>>::iterator siter;

   for (siter=stats.begin(); siter!=stats.end(); ++siter)
      std::cout << (*siter).first << " "
           << "было заменено "
           << (*siter).second
           << (" раз(а)\n");
}

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

Наш словарь подстановок:

key: 'em value: them
key: cuz value: because
key: gratz value: grateful
key: nah value: no
key: pos value: suppose
key: sez value: says
key: tanx value: thanks
key: wuz value: was

Исходный вектор строк:
nah I sez tanx cuz I wuz pos
to not cuz I wuz gratz

Преобразованный вектор строк:
no I says thanks because I was suppose
to not because I was grateful

И напоследок статистика:

cuz было заменено 2 раз(а)
gratz было заменено 1 раз(а)
nah было заменено 1 раз(а)
pos было заменено 1 раз(а)
sez было заменено 1 раз(а)
tanx было заменено 1 раз(а)
wuz было заменено 2 раз(а)

6.12.5. Удаление элементов std::map

Существуют три формы функции-члена erase() для удаления элементов отображения. Для единственного элемента используется erase() с ключом или итератором в качестве аргумента, а для последовательности эта функция вызывается с двумя итераторами. Например, мы могли бы позволить удалять элементы из text_map таким образом:

std::string removal_word;
std::cout << "введите удаляемое слово: ";
std::cin >> removal_word;

if (text_map->erase(remova1_word))
  std::cout << "ok: " << remova1_word << " удалено\n";
else std::cout << "увы: " << remova1_word << " не  найдено!\n";