C++ STL & Qt. Занятие 01.

Темы лекции: Введение в библиотеку STL.
Практическое задание: Строки, контейнеры, регулярные
выражения.
Тренер: Игорь Шкулипа, к.т.н.
С++ Библиотеки STL и Qt. Занятие 1

http://www.slideshare.net/IgorShkulipa 2
STL
STL (Standard Template Library) - Стандартная Библиотека Шаблонов
предоставляет набор хорошо сконструированных и согласованно
работающих вместе обобщённых компонентов C++.
Особая забота была проявлена для обеспечения того, чтобы все
шаблонные алгоритмы работали не только со структурами данных в
библиотеке, но также и с встроенными структурами данных C++.
Практически все современные компиляторы C++ содержат библиотеку
STL. Изначально она настроена на работу практически с любыми
данными, что обеспечивается набором шаблонов функций и классов.

Структура библиотеки
Библиотека содержит пять основных видов компонентов:
• алгоритм (algorithm) - определяет вычислительную процедуру.
• контейнер (container) - управляет набором объектов в памяти.
• итератор (iterator) - обеспечивает для алгоритма средство
доступа к содержимому контейнера.
• функциональный объект (function object) - инкапсулирует
функцию в объекте для использования другими компонентами.
• адаптер (adapter) - адаптирует компонент для обеспечения
различного интерфейса.

Требования к использованию
Все типы, представленные в сегменты STL должны обладать, как
минимум, следующими элементами:
• Открытый конструктор копирования.
• Открытый оператор присваивания.
• Открытый деструктор.
Кроме того, контейнеры должны иметь открытый оператор сравнения,
указанный по умолчанию operator<.

Операторы
template <class Tl, class T2>
inline bool operator!=(const T1& x, const T2& y) {
return !(x == y);
}
inline bool operator>(const T1& x, const T2& y) {
return y < x;
}
inline bool operator<=(const T1& x, const T2& y) {
return !(y < x);
}
inline bool operator>=(const T1& x, const T2& y) {
return !(x < y);
}
Чтобы избежать избыточных определений, библиотека обеспечивает
следующее:

Пара
Библиотека так же включает шаблоны для разнородных пар значений:
template <class T1, class T2>
struct pair {
T1 first;
T2 second;
pair() {}
pair(const T1& x, const T2& y) : first(x), second(y) {}
};
inline bool operator==(const pair<Tl,T2>& x, const pair<Tl,T2>& y) {
return x.first == y.first && x.second == y.second;
}
inline bool operator<(const pair<Tl,T2>& x, const pair<Tl,T2>& y) {
return x.first < y.first
|| (!(y.first < x.first) && x.second < y.second);
}

Функци make_pair()
Библиотека обеспечивает соответствующую шаблонную функцию
make_pair, чтобы упростить конструкцию пар.
inline pair<Tl,T2> make_pair(const T1& x, const T2& y) {
return pair<Tl,T2>(x, y);
}
То есть, вместо выражения:
return pair<int, double>(5, 3.1415926);
можно написать:
return make_pair(5, 3.1415926);

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

Паттерн Iterator
Назначение паттерна Iterator
• Предоставляет способ последовательного доступа ко всем
элементам составного объекта, не раскрывая его внутреннего
представления.
• Абстракция в стандартных библиотеках C++ и Java, позволяющая
разделить классы коллекций и алгоритмов.
• Придает обходу коллекции "объектно-ориентированный статус".
• Полиморфный обход.

Интерфейсы
template<class Type>
class IIterator
{
public:
virtual Type Next()=0;
virtual Type First()=0;
virtual bool Finished()=0;
virtual Type Current()=0;
};
class IIterCollection
{
public:
virtual IIterator<Type>* GetIterator()=0;
};

Реализация коллекции
template <class Type>
class IterCollection: public IIterCollection<Type>
{
private:
vector<Type> items;
public:
IterCollection(int number) {
for (int i=0;i<number;i++)
{
items.push_back(rand()%number);
}
}
IIterator<Type>* GetIterator() {
return new Iterator<Type>(this);
}
Type Get(int i) {
return items[i];
}
int GetCount() {
return items.size();
}
};

Реализация итератора
class Iterator : public IIterator<Type>
{
private:
IterCollection<Type>* collection;
int current;
public:
Iterator(IterCollection<Type>* col) {
collection = col;
current = 0;
}
Type First() {
return collection->Get(0);
}
Type Current() {
return collection->Get(current);
}
bool Finished() {
return (current >= collection->GetCount());
}
Type Next() {
return collection->Get(current++);
}
};

Использование
int main(int argc, char* argv[])
{
IIterCollection<int>* ic= new IterCollection<int>(10);
IIterator<int>* iter = ic->GetIterator();
while (!iter->Finished())
{
cout<<iter->Next()<<"n";
}
return 0;
}
1
7
4
0
9
4
8
8
2
4

Основные итераторы STL

Итераторы ввода
Итераторы ввода стоят в самом низу иерархии итераторов. Это наиболее простые
из всех итераторов STL, и доступны они только для чтения.
Итераторы ввода поддерживают операции равенства, разыменования и инкремента.
==, !=, *i, ++i, i++, *i++
Специальным случаем итератора ввода является istream_iterator.
Пример:
#include <iostream>
#include <iterator>
using namespace std;
{
istream_iterator<int> intReader(cin);
istream_iterator<int> intReaderEOF;
while (intReader != intReaderEOF) {
cout << *intReader << " read.n";
++intReader;
}
return 0;
}
1 2 4 1 5 2 3
1 read.
2 read.
4 read.
1 read.
5 read.
2 read.
3 read.
2 3 3
2 read.
3 read.
3 read.

Итераторы вывода
Итераторы вывода – это противоположность итераторам ввода. Служат
они для ссылки на область памяти, куда выводятся данные.
Разыменовывать такие итераторы нужно только для того, чтобы
присвоить некое значение объекту, на который итератор ссылается.
Пример:
#include <iostream>
#include <iterator>
{
int array[10]={1, 2, 4, 3, 6, 5, 8, 7, 0, 9};
ostream_iterator<int> intWritter1(cout, "n");
ostream_iterator<int> intWritter2(cout, "_");
copy(array, array+10, intWritter1);
copy(array, array+10, intWritter2);
return 0;
}
1
2
4
3
6
5
8
7
0
9
1_2_4_3_6_5_8_7_0_9_

Одно и двунаправленные итераторы
Если соединить итераторы ввода и вывода, то получится
однонаправленный итератор, который может перемещаться по
цепочке объектов в одном направлении.
Для такого перемещения в итераторе определены операции инкремента
(++) и операции сравнения (== и !=), присвоения (=) и
разыменовывания (*).
Двунаправленные итераторы во многом аналогичны
однонаправленным с возможностью обратного обхода и широко
применяются в реверсивных алгоритмах.
vector <int>::iterator iter;

Итераторы произвольного доступа
Итераторы произвольного доступа - это такие итераторы, которые не
только дают легко обращаться к произвольному элементу. Несмотря на
то, что мы изменяем итератор переприсваиванием в него значения, на
контейнер это никак не влияет.
Реверсивные итераторы
Получить реверсивный итератор для контейнера можно вызовом метода
rbegin(), а реверсивное значение "за пределом" возвращается методом
rend().
Итераторы вставки
Итераторы вставки предназначены для вставки элементов в нужное
место.
Константные итераторы
Константный итератор не допускает изменения данных, на которые он
ссылается. Можно считать константный итератор указателем на
константу.

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

Контейнеры
Контейнеры представляют собой объекты STL, которые предназначены
для хранения данных.
Контейнер Описание Файл
bitset Битовое множество <bitset>
deque Двусторонняя очередь, очередь с двусторонним
доступом
<deque>
list Линейный список <list>
map Отображение. Хранит пары "ключ-значение", в которых
каждый ключ связан только с одним значением
<map>
multimap
Мультиотображение. Хранит пары "ключ-значение", в
которых каждый ключ может быть связан с двумя или
более значениями
<map>
multiset Множество, в котором каждый элемент необязательно
уникален
<set>
priority_queue Приоритетная очередь <queue>
queue Очередь <queue>
set Множество, в котором каждый элемент уникален <set>
stack Стек <stack>
vector Динамический массив <vector>

typedef’ы
Поскольку имена типов в объявлениях шаблонных классов произвольны,
контейнерные классы объявляют typedef - версии этих типов, что
конкретизирует имена типов.
typedef-имя Описание
size_type Некоторый целый тип, приблизительно аналогичный типу
size_t
reference Ссылка на элемент
const_reference Константная ссылка на элемент
iterator Итератор
const_iterator Константный итератор
reverse_iterator Реверсивный итератор
const_reverse_iterator Константный реверсивный итератор
value_type Тип значения, хранимого в контейнере
allocator_type Тип распределителя (памяти)
key_type Тип ключа
key_compare Тип функции, которая сравнивает два ключа
mapped_type Тип значения, сохраняемого в отображении
value_compare Тип функции, которая сравнивает два значения

Методы, общие для всех контейнеров
Итераторы:
• begin() - указывает на первый элемент
• end() - указывает на элемент, следующий за последним
• rbegin() - указывает на первый элемент в обратной последовательности
• rend() - указывает на элемент, следующий за последним в обратной
последовательности
Доступ к элементам:
• front() - ссылка на первый элемент
• back() - ссылка на последний элемент
• operator [](i) - доступ по индексу без проверки
• at(i) - доступ по индексу с проверкой
Вставка элементов:
• insert(p, x) - добавление х перед элементом, на который указывает р
• insert(p, n, x) - добавление n копий х перед р
• insert(p, first, last) - добавление элементов из [first:last] перед р
• push_back(x) - добавление х в конец
• push_front(x) - добавление нового первого элемента (только для списков и
очередей с двумя концами)

Методы, общие для всех контейнеров
Удаление элементов:
• pop_back() - удаление последнего элемента
• pop_front() - удаление первого элемента (только для списков и
очередей с двумя концами)
• erase(p) - удаление элемента в позиции р
• erase(first, last) - удаление элементов из [first:last]
• clear() - удаление всех элементов
Другие методы:
• size() - число элементов
• empty() - контейнер пуст
• capacity() - память, выделенная под вектор (только для векторов)
• reserve(n) - выделяет память для контейнера под n элементов
• resize(n) - изменяет размер контейнера (только для векторов,
списков и очередей с двумя концами)
• swap(x) - обмен местами двух контейнеров
• ==, !=, < операции сравнения

Операции, общие для всех контейнеров
Операции присваивания:
• operator =(x) - контейнеру присваиваются элементы контейнера
х
• assign(n, x) - присваивание контейнеру n копий элементов х (не
для ассоциативных контейнеров)
• assign(first, last) - присваивание элементов из диапазона
[first:last]
Ассоциативные операции:
• operator [](k) - доступ к элементу с ключом k
• find(k) - находит элемент с ключом k
• lower_bound(k) - находит первый элемент с ключом k
• upper_bound(k) - находит первый элемент с ключом, большим k
• equal_range(k) - находит lower_bound (нижнюю границу) и
upper_bound (верхнюю границу) элементов с ключом k

vector
Простейшим контейнером STL является vector. Это всего лишь обычный
(C-like) массив с расширенной функциональностью. Контейнер vector
- единственный в STL обратно-совместимый с чистым C контейнер. Это
означает, что vector по сути дела и является обычным динамическим
массивом с рядом дополнительных функций.
vector<int> v(10);
for(int i = 0; i < 10; i++) {
v[i] = (i+1)*(i+1);
}
for(int i = 9; i > 0; i--) {
v[i] -= v[i-1];
}

list
Класс list поддерживает функционирование двунаправленного
линейного списка. В отличие от вектора, в котором реализована
поддержка произвольного доступа, список позволяет получать к своим
элементам только последовательный доступ. Доступ к его элементам
возможен в двух направлениях: от начала к концу и от конца к
началу.
list<int> mylist;
int a;
do {
cin >> a;
mylist.push_back (a);
} while (a)

deque
Термин "дек" (deque) происходит от сокращения фразы "double-ended
queue" (двусторонняя очередь). Дек представляет собой
динамический массив, реализованный таким образом, что может расти
в обоих направлениях. Таким образом, операции вставки элементов в
конец и в начало коллекции выполняются очень быстро, а вставка в
середину занимает больше времени, потому что требует перемещения
элементов.
deque<double> coll;
for (int i=0; i<10; i++)
{
coll.push_front(i);
}

set
Контейнер set содержит множество элементов. Строго говоря, set
обеспечивает следующую функциональность:
• добавить элемент в рассматриваемое множество, при этом
исключая возможность появления дублей;
• удалить элемент из множества;
• узнать количество (различных) элементов в контейнере;
• проверить, присутствует ли в контейнере некоторый элемент.
set<int> s;
for(int i = 1; i <= 100; i++) {
s.insert(i);
}
s.insert(42); // ничего не произойдёт
for(int i = 2; i <= 100; i += 2) {
s.remove(i);
}

map
map очень похож на set, за исключением того, что вместо элементов map
хранит пары элементов <ключ, значение>. Поиск при этом
осуществляется только по ключу.
Важно помнить, что operator [] при обращении к несуществующему
элементу в map создаст его. Новый элемент при этом будет
инициализирован нулём либо конструктором по умолчанию.
map<string, int> M;
M["One"] = 1;
M["Two"] = 2;
M["Five"] = 5;
M["Ten"] = 10;
int x = M["One"] + M["Two"];
if(M.find("Five") != M.end()) {
M.erase("Five");
}
(!) Элементы map и set хранятся упорядоченными. Поэтому не
следует при работе с iterator модифицировать iterator->first

multimap и multiset
multimap – это map, за исключением того, что каждый ключ может быть
связан с двумя или более значениями.
multiset – это set, в котором каждый элемент необязательно уникален
typedef multimap <string, string> Dictionary;

string
Включаемый файл <string> содержит описания двух классов
строк, первый с символами типа char (однобайтовые
символы), второй с символами типа wchar_t (двухбайтовые
символы)
typedef basic_string <char> string;
typedef basic_string <wchar_t> wstring;

Доступ к элементу строки и добавление в конец строки
Доступ к элементу строки
⚫ at(size_type pos) const - доступ к символу в позиции pos;
⚫ reference at(size_type pos) - доступ к символу в позиции pos.
Если генерация исключения не нужна при некорректном аргументе pos, то
можно воспользоваться операцией [].
Добавление в конец строки
⚫ append(const basic_string& s) – добавление строки;
⚫ append(const basic_string& s, size_type pos, size_type npos) -
добавление части строки;
⚫ append(const char* s) - добавление C-строки;
⚫ append(const char* s, size_type n) - добавление части C строки;
⚫ append(size_type n, char c ) - добавление n символов c;
⚫ append(InputIterator first, InputIterator last) - добавление строки
заданной итераторами.
Методы возвращают ссылку на себя (*this). В качестве альтернативы
методам с одним аргументом можно воспользоваться операцией +=.

Присваивание данных строке
Присваивание данных строке
⚫ assign(const basic_string& s) – присваивание строки;
⚫ assign (const basic_string& s,size_type pos, size_type n) -
присв. части stl строки;
⚫ assign (const char* s) - присваивание C-строки;
⚫ assign (const char* s, size_type n) - присваивание части C-
строки;
⚫ assign (size_type n, char c) - присваивание n символов c;
⚫ assign (InputIterator first, InputIterator last) -
присваивание строки заданной итераторами.
Методы возвращают ссылку на себя (*this). В качестве альтернативы
методам с одним аргументом можно воспользоваться операцией =.

Методы сравнения строк
Сравнение строк
⚫ compare (const basic_string& str) - сравнение с stl строкой;
⚫ compare (size_type pos1, size_type n1, const basic_string&
str) const - сравнение с частью stl строки;
⚫ compare (size_type pos1,size_type n1,const basic_string&
str,size_type pos2,size_type n2) const - сравнение части stl
строки с частью stl строки;
⚫ compare (char* s) const - сравнение с C-строкой;
⚫ compare (size_type pos, size_type n1, char* s) const -
сравнение с C-строкой;
⚫ compare (size_type pos, size_type n1, char* s, size_type n2)
const - сравнение с C-строкой.
Методы сравнения возвращают следующие значения:
⚫ 0 - строки равны;
⚫ <0 - строка лексиграфически меньше со сравниваемой строкой;
⚫ >0 - строка лексиграфически больше со сравниваемой строкой.
В качестве альтернативы методам с одним аргументом можно
воспользоваться операциями ==, !=, < >, <=, >=.

Методы вставки данных
Вставка данных
⚫ insert (size_type pos1, const basic_string& s) - вставка stl
строки;
⚫ insert (size_type pos,const basic_string& s,size_type
pos2=0,size_type n=npos) - вставка части stl строки;
⚫ insert (size_type pos, const char* s) - вставка C-строки;
⚫ insert (size_type pos, const char* s, size_type n) - вставка
части C строки;
⚫ insert (size_type pos, size_type n, char c) - вставка
нескольких одинаковых символов.
Вставка данных, позиция вставки указана итератором:
⚫ insert (iterator p, char) - вставка символа;
⚫ insert (iterator p, size_type n, char c) - вставка нескольких
одинаковых символов;
⚫ insert (iterator p,InputIterator f,InputIterator l) - вставка
строки заданной итераторами.
Большинство методов возвращают ссылку на себя (*this).

Методы замены
Замена части строки
Замена участка строки, указанного позицией и размером:
⚫ replace (size_type pos, size_type n1, const basic_string& s) - замена
stl строкой;
⚫ replace (size_type pos1,size_type n1,const basic_string& str,size_type
pos2,size_type n2) - замена частью stl строкой;
⚫ replace (size_type pos, size_type n1, const char* s) - замена C строкой;
⚫ replace (size_type pos,size_type n1,const char* s,size_type n2) -
замена частью C строки;
⚫ replace (size_type pos, size_type n1, size_type n2, char c) - замена
несколькими символами.
Замена участка, указанного итераторами:
⚫ replace (iterator i1, iterator i2,const basic_string& str) - замена stl
строкой;
⚫ replace (iterator i1, iterator i2, const char* s) - замена C строкой;
⚫ replace (iterator i1, iterator i2, const char* s,size_type n) - замена
частью C строки;
⚫ replace (iterator i1, iterator i2, size_type n,char c) - замена
несколькими символами;
⚫ replace (iterator i1, iterator i2,InputIterator j1, InputIterator j2) -
замена строкой заданной итераторами.
Методы возвращают ссылку на себя (*this).

Методы поиска элементов строки
Поиск указанного элемента
⚫ find (const string& str) const - поиск stl строки;
⚫ find (const string& str, size_type idx) const - поиск stl строки
с указанной позиции;
⚫ find (const charT* s, size_type pos = 0) const - поиск C строки
с указанной позиции;
⚫ find (const charT* s, size_type pos, size_type n) const -
поиск подстроки с указанной позиции;
⚫ find (charT c, size_type pos = 0) const - поиск символа с
указанной позиции.
Также есть аналогичные методы rfind, делающие поиск справа налево.
Методы возвращают позицию найденного элемента или npos (обычно
равной -1).

Поиск символов, не входящих в строку
Поиск символа не входящего в строку
⚫ find_first_not_of (const basic_string& str, size_type
pos = 0) const;
⚫ find_first_not_of (const char* s,size_type
pos,size_type n) const;
⚫ find_first_not_of (const char* s,size_type pos=0)
const;
⚫ find_first_not_of (char c, size_type pos = 0) const.
Методы возвращают позицию найденного символа или npos (-1).

Поиск символов, входящих в строку
Поиск символа входящего в указанную строку:
⚫ find_first_of (const basic_string& str,size_type pos=0)
const;
⚫ find_first_of (const char* s,size_type pos,size_type n)
const;
⚫ find_first_of (const char* s, size_type pos=0) const;
⚫ find_first_of (charT c, size_type pos=0) const;
Методы возвращают позицию найденного символа или npos (-1).

Удаление символов из строки
Удаление символов строки
⚫ erase (size_type pos=0,size_type n=npos) - удаляет n
символов с указанной позиции;
⚫ erase (iterator p) - удаляет один символ в указанной
позиции;
⚫ erase (iterator f, iterator l) - удаляет символы с
позиции f по l.

Другие методы строковых классов
begin() - итератор на первый символа;
end() - итератор на позицию за последним символом;
rbegin() - итератор на последний элемент (для обратных
алгоритмов);
rend() - итератор на позицию перед первым элементом (для
обратных алгоритмов);
size() - размер строки;
substr(size_type pos = 0, size_type n=npos) const -
выделение подстроки;
c_str() - преобразование в C строку (возвращается указатель
на первый символ);
copy(char* buf, size_type buf_size) const - копировать
buf_size символов в буфер;
copy(char* buf, size_type buf_size, size_type pos) const -
копировать buf_size символов с указанной позиции в буфер;

Пример
#include <iostream>
#include <iterator>
#include <string>
#include <map>
#include <list>
{
string strEnglishText = "
99 little bugs in the coden
99 little bugs in the coden
Take one down, patch aroundn
117 little bugs in the code.";
map<string, string> dictionary;
dictionary.insert(std::pair<string, string>("little", "маленьких"));
dictionary.insert(std::pair<string, string>("bugs", "багов"));
dictionary.insert(std::pair<string, string>("in the", "в"));
dictionary.insert(std::pair<string, string>("code", "коде"));
dictionary.insert(std::pair<string, string>("Take", "Взять"));
dictionary.insert(std::pair<string, string>("one", "одну"));
dictionary.insert(std::pair<string, string>("patch", "пропатчить"));
dictionary.insert(std::pair<string, string>("around", "вокруг"));

Пример. Использование итераторов
list<string> english;
list<string> russian;
map<string, string>::iterator fIter=dictionary.begin();
map<string, string>::reverse_iterator rIter=dictionary.rbegin();
while (fIter!=dictionary.end())
{
english.push_back(fIter->first);
fIter++;
}
while (rIter!=dictionary.rend())
{
russian.push_front(rIter->second);
rIter++;
}

Пример. Отсортированный вывод
english.sort();
russian.sort();
list<string>::iterator listIter1=english.begin();
list<string>::reverse_iterator listIter2=russian.rbegin();
cout<<"Dictionary in Crazy Order:n";
while (!(
(listIter1==english.end())||
(listIter2==russian.rend())))
{
cout<<listIter1->c_str()<<" - "<<listIter2->c_str()<<"n";
listIter1++;
listIter2++;
}
Dictionary in Crazy Order:
Take - пропатчить
around - одну
bugs - маленьких
code - коде
in the - вокруг
little - в
one - багов
patch - Взять

Пример. Работа со словарем
string strRussianText=strEnglishText;
map<string, string>::iterator iter;
for (iter=dictionary.begin(); iter!=dictionary.end();iter++)
{
int iPos=strRussianText.find(iter->first);
while (iPos>0)
{
strRussianText=
strRussianText.replace(iPos,iter->first.size(),iter->second);
iPos=strRussianText.find(iter->first);
}
}
cout<<strEnglishText<<"nn";
cout<<strRussianText<<"nn";
return 0;
}
99 little bugs in the code
99 little bugs in the code
Take one down, patch around
117 little bugs in the code.
99 маленьких багов в коде
99 маленьких багов в коде
Взять одну down, пропатчить вокруг
117 маленьких багов в коде.

Регулярные выражения
Регулярные выражения - формальный язык поиска и осуществления
манипуляций с подстроками в тексте, основанный на использовании
метасимволов. По сути это строка-образец, состоящая из символов и
метасимволов и задающая правило поиска.
Пример:
string emailExpression =
"([A-Z;a-z;0-9;x2E;x2D;_]+)?@([A-Z;a-z;0-9;x2E;-;]+)?";
Ссылка на справочник по языку регулярных выражений
http://msdn.microsoft.com/ru-ru/library/az24scfc.aspx

Регулярные выражения в С++
Библиотека, объявленная в заголовочном файле <regex>, содержит в
себе несколько новых классов и функций для работы с регулярными
выражениями:
• Регулярные выражения представлены в виде экземпляров класса
std::regex;
• Результаты поиска представлены в виде экземпляров класса
std::match_results.

Пример
#include <iostream>
#include <string>
#include <regex>
int main(int argc, char* argv[]) {
string strText =
"Lorem ipsum dolor sit amet, vasya.pupkin@gmail.com consectetur adipiscing elit.
In posuere, elit ut tristique condimentum, lectus est sodales nibh,
sed adipiscing velit address@mail.ru lectus vel felis. Praesent id urna
ut quam dapibus sollicitudin sit amet et mi. Quisque in magna nisi, in
scelerisque mi admin@mysite.com.ua! Vestibulum suscipit lacinia tempor. Donec
euismod massa sit amet tellus consectetur dapibus. Donec nisl justo, egestas at
mattis ut, sagittis eu ipsum. Aliquam porttitor massa support@somedomain.info in.";
cout<<strText<<"nnn";
string strFind = "([A-Z;a-z;0-9;x2E;x2D;_]+)?@([A-Z;a-z;0-9;x2E;-;]+)?";
string strReplace = "$1";
regex rx(strFind);
cmatch matches;
if ( regex_search(strText.c_str(), matches, rx) ) {
for (int i=0;i<matches.size();i++) {
cout<<matches[i].first<<"n";
} }
string strResult= regex_replace(strText, rx, strReplace);
cout<<"nnn"<<strResult;
return 0;
}

Результат
Lorem ipsum dolor sit amet, vasya.pupkin@gmail.com consectetur adipiscing elit.
In posuere, elit ut tristique condimentum, lectus est sodales nibh, sed adipisci
ng velit address@mail.ru lectus vel felis. Praesent id urna ut quam dapibus soll
icitudin sit amet et mi. Quisque in magna nisi, in scelerisque mi admin@mysite.c
om.ua! Vestibulum suscipit lacinia tempor. Donec euismod massa sit amet tellus c
onsectetur dapibus. Donec nisl justo, egestas at mattis ut, sagittis eu ipsum. A
liquam porttitor massa support@somedomain.info in.
vasya.pupkin@gmail.com
address@mail.ru
admin@mysite.com.ua
support@somedomain.info
Lorem ipsum dolor sit amet, vasya.pupkin consectetur adipiscing elit. In posuere
, elit ut tristique condimentum, lectus est sodales nibh, sed adipiscing velit a
ddress lectus vel felis. Praesent id urna ut quam dapibus sollicitudin sit amet
et mi. Quisque in magna nisi, in scelerisque mi admin! Vestibulum suscipit lacin
ia tempor. Donec euismod massa sit amet tellus consectetur dapibus. Donec nisl j
usto, egestas at mattis ut, sagittis eu ipsum. Aliquam porttitor massa support i
n.

Лабораторная работа № 1. Строки и контейнеры
• Создать словарь «ошибочных слов», например hello-hllo-helol...
• На основе этого словаря, исправить ошибки в текстовых файлах в
указанной директории.
• В этих же файлах, с помощью регулярных выражений, найти и
заменить все номера мобильных телефонов
с (012) 345-67-89 на +380 12 345 67 89.

C++ STL & Qt. Занятие 01.

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to C++ STL & Qt. Занятие 01.

Similar to C++ STL & Qt. Занятие 01. (20)

More from Igor Shkulipa

More from Igor Shkulipa (20)

C++ STL & Qt. Занятие 01.