ВВЕДЕНИЕ
Стандартную библиотеку С++ можно разделить на две части. К первой части относятся функции, макросы, типы и константы, унаследованные из библиотеки С; ко второй – классы и другие средства С++.
Классы стандартной библиотеки можно разделить на следующие группы.
Потоковые классы – предназначены для управления потоками данных между оперативной памятью и внешними устройствами, а также в пределах оперативной памяти.
Строковый класс – предназначены для работы с символьными переменными.
Контейнерные классы – реализуют структуры для хранения данных (списки, векторы, множества).
Итераторы – предназначены для унифицированного доступа к элементам классов.
Математические классы – поддерживают обработку массивов с плавающей точкой и работу с комплексными числами.
Диагностические классы – обеспечивают динамическую идентификацию типов и объектно-ориентированную обработку ошибок.
Остальные классы обеспечивают динамическое распределение памяти и ряд других функций.
Для использования средств стандартной библиотеки в программу следует включить соответствующие заголовочные файлы.
Потоковые классы
Поток – это абстрактное понятие, относящееся к любому переносу данных от источника к приемнику.
Чтение данных из потока извлечением, вывод в поток – помещением или включением. Поток определяется как последовательность байтов и не зависит от конкретного устройства, с которым производится обмен. Обмен с потоком для увеличения скорости передачи данных производится, как правило, через специальную область данных – буфер.
По направлению обмена потоки можно разделить на входные (данные вводятся в память) и двунаправленные (допускающие как извлечение, так и включение).
По виду устройств, с которыми работает поток, можно выделить стандартные, файловые и строковые потоки.
Стандартные потоки предназначены для передачи данных от клавиатуры и на экран.
Файловые потоки – для обмена информацией с файлами на внешних устройствах.
Строковые потоки – для работы с массивами символов.
Для поддержки потоков библиотека С++ содержит иерархию классов, построенную на основе двух базовых классов – ios и sterambuf. Класс ios содержит общие для ввода и вывода поля и методы, класс steambuf обеспечивает буферизацию потоков и их взаимодействие с физическими устройствами.
Далее перечисляются часто используемые классы потоков:
ios – базовый класс потоков;
istream – класс входных потоков;
ostream – класс выходных потоков;
iostream – класс двунаправленных потоков;
istringstream – класс входных строковых потоков;
ostringstream – класс выходных строковых потоков;
stringstream – класс двунаправленных потоков;
ifstream – класс входных файловых потоков;
ofstream – класс выходных файловых потоков;
fstream – класс двунаправленных файловых потоков.
Описание классов находится в заголовочных файлах:
<ios> – базовый класс ввода/вывода;
<iosfwd> – предварительные объявления средств ввода/вывода;
<istream> – шаблон потока ввода;
<ostream> – шаблон потока вывода;
<iostream> – стандартные объекты и операции с потоками ввода/вывода;
<fstream> – потоки ввода/вывода в файлы;
<sstream> – потоки ввода/вывода в строки;
<streambuf> – буферизация потоков ввода/вывода;
<iomanip>–манипуляторы (см. далее).
Стандартные потоки
Заголовочный файл <iostream> помимо описания классов для ввода/вывода содержит четыре предопределенных объекта (табл.1).
Таблица 1
Предопределенные объекты
| Объект | Класс | Описание |
| cin | istream | Связывается с клавиатурой (стандартным буферизованным вводом) |
| cout | ostream | Связывается с экраном (стандартным буферизованным выводом) |
Окончание табл.1
| cerr | ostream | Связывается с экраном (стандартным небуферизованным выводом), куда направляются сообщения об ошибках |
| clog | ostream | Связывается с экраном (стандартным буферизованным выводом), куда направляются сообщения об ошибках |
В классах istream и ostream операции извлечения из потока >> и помещения в поток << определены путем перегрузки операций сдвига.
Числовые значения можно вводить в десятичной или шестнадцатеричной системе счисления (с префиксом 0x) со знаком или без знака. Вещественные числа представляются в форме с фиксированной точкой или плавающей точкой (с порядком).
При вводе строки извлечение происходит до ближайшего пробела (вместо него в строку записывается 0-символ).
Значения указателей вводятся в шестнадцатеричной системе счисления.
Форматирование данных
Форматирование в потоковых классах выполняется тремя способами: с помощью флагов, манипуляторов и форматирующих методов.
Флаги и форматирующие методы
Флаги – это отдельные биты, объединенные в поле x_flags типа long класса ios.
Таблица 2
Некоторые флаги форматирования
| Флаг | Умолчание | Описание |
| skipws | + | При извлечении пробельные символы игнорируются |
| left | - | Выравнивание по левому краю поля |
| right | + | Выравнивание по правому краю поля |
| internal | - | Знак числа выводится по левому краю, число – по правому |
| dec | + | Десятичная система счисления |
| oct | - | Восьмеричная система счисления |
| hex | - | Шестнадцатеричная система счисления |
| showbase | - | Выводится основание системы счисления (0x – шестнадцатеричная, 0 – восьмеричная) |
| showpoint | - | При выводе числа печатается точка и дробная часть числа |
| uppercase | - | Использование при выводе верхнего регистра |
| scientific | - | Печать вещественных чисел в экспоненциальной форме |
| fixed | - | Печать вещественных чисел в форме с фиксированной точкой |
Для управления флагами в классе ios есть методы flags, setf и unsetf.
long ios:: flags (long); – возвращает текущие флаги потока;
long ios:: flags (long); – присваивает флагам значение параметра;
long ios:: setf (long, long); – присваивает флагам, биты которых установлены в первом параметре, значение соответствующих битов второго параметра;
long ios:: setf (long, long); – устанавливает флаги, биты которых установлены в параметре;
long ios:: unsetf (long, long); – сбрасывает флаги, биты которых установлены в параметре;
Все функции возвращают прежние флаги потока.
Кроме флагов для форматирования используются поля класса ios:
int x_width – минимальная ширина поля;
int x_precision – количество цифр в дробной части числа;
int x_fill – символ заполнения поля вывода.
Для управления этими полями используются методы width, precision и fill:
int ios:: width () – возвращает значение ширины поля вывода;
int ios:: width () – устанавливает значение ширины поля вывода;
int ios:: precision () – возвращает значение точности представления дробной части;
int ios:: precision (int) – устанавливает значение точности представления дробной части;
char fill () – возвращает текущий символ заполнения;
char fill (char) – устанавливает значение текущего символа заполнения (по умолчанию – пробел).
Перед установкой некоторых флагов требуется сбросить флаги, которые не могут быть установлены одновременно с ними. Для этого удобно использовать вторым параметром метода setf статические константы класса ios:
adjustfield (left | right | internal)
basefield (dec | oct | hex)
floatfield (scientific | fixed)
Пример
# include <iostream.h>
int main () {
long a = 100, b = 077;
cout.width (7); cout.unsetf (ios:: dec);
cout.setf (ios:: hex | ios:: showbase | ios::uppercase);
cout << a;
cout.width (7);
cout << b << endl;
double d = 0.12, c = 1.3e-4;
cout.setf(ios:: left);
cout << d << endl;
cout << c;
return 0;
}
Результат работы программы:
0X3T8 0X3F
0.12
0.00013
Манипуляторы
Манипуляторы – это функции, которые можно включать в цепочку операций помещения и извлечения для форматирования данных. Манипуляторы бывают простые и параметризованные. Манипуляторами пользоваться удобнее чем флагами.
Простые манипуляторы
dec – устанавливает флаг десятичной системы;
oct – устанавливает флаг восьмеричной системы;
hex – устанавливает флаг шестнадцатеричной системы;
ws – устанавливает при вводе извлечение пробельных символов;
endl – при выводе включает в поток символ новой строки и выгружает буфер;
ends – при выводе включает в поток нулевой символ;
flush – при выводе выгружает буфер.
Изменение системы счисления действует до следующего явного изменения.
Пример
…
cout << 13 << hex << ‘ ‘ << 13 << oct << ‘ ‘ << 13 << endl;
…
На экране:
13 d 15
Параметризованные манипуляторы
Параметризованные манипуляторы – это манипуляторы, имеющие аргумент. Для их использования необходимо подключать заголовочный файл <iomanip>.
setbase (int n) – задает основание системы счисления (n = 8, 10, 16 или 0). 0 – основание по умолчанию (десятичное, кроме случаев, когда вводятся восьмеричные или шестнадцатеричные числа);
resetiosflags (long) – сбрасывает флаги состояния потока, биты которых установлены в параметре;
setfill (int) – устанавливает символ-заполнитель с кодом, равным значению параметра;
setprecision (int) – устанавливает максимальное количество цифр в дробной части чисел;
setw (int) – устанавливает максимальную ширину поля вывода;
setiosflags (long) – устанавливает флаги состояния потока, биты которых в параметре равны 1.
Пример
…
double d (1.234);
cout << setfill (‘.’) << setprecision (4)
<< setiosflags (ios:: showpoint | ios:: fixed);
cout << setw (12) << d << endl;
…
На экране:
……1.2340
Методы обмена с потоком
В потоковых классах наряду с операциями извлечения >> и включения << определены методы для неформатированного чтения и записи в поток (при этом преобразования данных не выполняются).
| Функция | Назначение |
| Класс istream | |
| gcount () | Возвращает количество символов, считанных с помощью последней функции неформатированного ввода |
| get () | Возвращает код извлеченного из потока символа или EOF |
| get (buf, num, lim = ‘\n’) | Считывает num-1 символов (или пока не встретится символ lim) и копирует их в строку buf. Вместо символа lim в строку записывается признак конца строки (‘\0’). Символ lim остается в потоке. Возвращает ссылку на текущий поток |
| getline (buf, num, lim = ‘\n’) | Аналогична get (), но копирует в buf и символ lim |
Продолжение таблицы
| ignore (num = 1, lim = EOF) | Считывает и пропускает символы до тех пор, пока не будет прочитано num символов (по умолчанию 1) или не встретится разделитель lim. Возвращает ссылку на текущий поток |
| peek () | Возвращает следующий символ без удаления его из потока или EOF, если достигнут конец файла |
| putback (c) | Помещает в поток символ с, который становится текущим при извлечении из потока |
| read (buf, num) | Считывает num символов (или все символы до конца файла, если их меньше num) в символьный массив buf и возвращает ссылку на текущий поток |
| readsome (buf, num) | Считывает num символов в символьный массив buf и возвращает количество считанных символов |
| seekg (pos) | Устанавливает текущую позицию чтения в значение pos |
| seekg (offs, org) | Перемещает текущую позицию чтения на offs байтов, считая от одной из трех позиций, определяемых параметром org: ios:: beg (от начала), ios:: cur (от текущей позиции) и ios:: end (от конца файла) |
| tellg () | Возвращает текущую позицию чтения потока |
| Класс ostream | |
| flush () | Записывает содержимое потока вывода на физическое устройство |
| рut (с) | Выводит в поток символ с и возвращает ссылку на поток |
Окончание таблицы
| seekg (pos) | Устанавливает текущую позицию записи в значение pos |
| seek (ofs, org) | Перемещает текущую позицию записи на offs байтов, считая от одной из трех позиций (см. выше) |
| tellg () | Возвращает текущую позицию записи потока |
| write (buf, num) | Записывает в поток num символов из массива buf и возвращает ссылку на поток |
Пример 1. Программа считывает строки из входного потока в символьный массив.
# include <iostream.h>
int main () {
const int N = 20, Len = 100;
char str [Len] [N]
int i = 0;
while (cin.getline (str [i], Len, ‘\n’) & & i < N) {
i ++;}
return 0;
}
Пример 2. Программа формирует файл test, в который вводится три строки (файловые потоки см. далее).
# include <iostream.h>
# include <fstream.h>
# include <string.h>
int main () {
// Запись в файл
ofstream out (“test”);
if (!out) {
cout << “Нельзя открыть файл для записи” << endl;
return 1;
}
char *str [ ] = {“the first line”, “the second line”, “the third line”};
for (int i = 0; i<3, ++ i) {
out.write (str [i], strlen (str [i]));
out.put (‘\n’);
}
out.close ();
// Чтение из файла
ifstream in (“test”);
if (! in) {
cout << “Нельзя открыть файл для чтения” << endl;
return 1;
}
char check_str [3] [30];
for (int i = 0; i < 3; ++ i) {
in.get (check_str [i], 30);
in.get (); }
for (int i = 0; i < 3; ++ i) cout << check_str [i] << endl;
in.close ();
return 0;
}
Пример 3. Программа с функциями peek () и putback ().
Эти функции позволяют упростить управление, когда неизвестен тип вводимой в каждый момент времени информации. В данной программе из файла считываются либо строки, либо целые числа. Строки и целые числа могут следовать в любом порядке.
# include <iostream.h>
# include <fstream.h>
# include <stdlib>
int main () {
char ch;
// Подготовка файла
ofstream out (“test”);
cout << “Нельзя открыть файл test для записи” << endl;
return1;
}
char str [80], *p;
out << 123 << “Это выполняется тест” << 23;
out << “Всем привет” << 99 << “Пока” << endl;
out.close ();
// Чтение файла
ifstream in (“test”);
if (!in) {
cout << “Нельзя открыть файл test для чтения” << endl;
return 1;
}
do {
p = str;
ch = in.peek (); // определяем тип следующего значения
if (isdigit(ch)) {
while (isalpha (*p = in.get ())) p ++; // считываем целые
in.putback (*p); // возврат символа в поток
*р = “\0”; // заканчиваем строку нулем
cout << “Число:” << atoi (str);
}
else if (isalpha (ch)) { //считываем строку
while (isalpha (*p = in.get ())) p ++;
in.putback (*p); // возврат символа в поток
*p = ‘\0’; // заканчиваем строку нулем
cout << “Строка:” << str;
}
else in.get (); // пропуск
cout << endl;
} while (!in.eof ());
in.close ();
return 0;
}
Результат работы программы:
Число: 123
Строка: Это
Строка: выполняется
Строка: тест
Число: 23
Строка: Всем
Строка: привет
Число: 99
Строка: Пока
Ошибки потоков
В базовом классе ios определено поле state, которое представляет собой состояние потока в виде совокупности битов:
enum io_state {
googbit = 0x00, // Нет ошибок
eofbit = 0x01, // Достигнут конец файла
failbit = 0x02, // Ошибка форматирования или преобразования
badbit = 0x04, // Серьезная ошибка, после которой пользоваться потоком
// нельзя
hardbit = 0x08 // Неисправность оборудования
};
Состоянием потока можно управлять с помощью следующих методов и операций:
int rdstate () – возвращает текущее состояние потока;
int eof () – возвращает ненулевое значение, если установлен флаг eofbit;
int fail () – возвращает ненулевое значение, если установлен один из флагов failbit, badbit или hardbit;
int good () – возвращает ненулевое значение, если сброшены все флаги ошибок;
void clear (int = 0) – параметр принимается в качестве состояния ошибки, при отсутствии параметра состояние ошибки устанавливается 0;
operator void *() – возвращает нулевой указатель, если установлен хотя бы один бит ошибки;
operator! () – возвращает ненулевой указатель, если установлен хотя бы один бит ошибки.
Пример. Наиболее часто используемые операции с флагами состояния потока:
// Проверить, установлен ли флаг flag
if (steam_obj.rdstate () & ios:: flag)
// Сбросить флаг flag
stream_obj.clear (rdstate () & ~ios:: flag)
// Установить флаг flag
stream_obj.clear (rdstate () | ios:: flag)
// Установить флаг flag и сбросить все остальные
stream_obj.clear (ios:: flag)
// Сбросить все флаги
stream_obj.clear ()
Операция void *() неявно вызывается всякий раз, когда поток сравнивается с нулем. Это поволяет записывть циклы вида:
while (stream_obj) {
// Все в порядке, можно производить ввод/вывод
}
Файловые потоки
Стадартная библиотека содержит три класса для работы с файлами:
ifstream – класс входных файловых потоков;
ofstream – класс выходных файловых потоков;
fstream – класс двунаправленных файловых потоков.
Эти классы являются производными от классов istream, ostream и iostream соответственно.
Использование файлов в программе предполагает следующие операции:
- создание потока;
- открытие потока;
- обмен (ввод/вывод);
- уничтожение потока;
- закрытие файла.
Каждый класс файловых потоков содержит конструкторы, с помощью которых можно создавать объекты этих классов различными способами.
Конструкторы без параметров создают объект соответствующего класса, не связывая его с файлом:
ifstream ();
ofstream ();
fstream ();
Конструкторы с параметрами создают объект соответствующего класса, открывают файл с указанным именем и связывают файл с объектом:
ifstream (const char * name, int mode = ios:: in);
ofstream (const char * name, int mode = ios:: out | ios:: trunc);
fstream (const char * name, int mode = ios:: in | ios:: out);
здесь второй параметр – это режим открытия файла.
Открыть файл в программе можно с использованием либо конструкторов, либо метода open, имеющего такие же параметры, как и в соответствующем конструкторе.
Пример 1
…
ifstream inpf (“input.txt”); // используем конструктор
if (! inpf) {
cout << “Невозможно открыть файл для чтения”;
return 1;
}
Пример 2
…
ofstream f;
f.open (“output.txt”, ios:: out); //используем метод open
if (!f) {
cout << “Невозможно открыть файл для записи”;
return 1;
}
Чтение и запись выполняются либо с помощью операций чтения и извлечения, аналогичных потоковым классам, либо с помощью методов классов.
Пример. Вывод на экран содержимого файла.
# include <fstream.h>
int main () {
char text [81], buf [81];
cout << “Введите имя файла”;
cin >> text;
ifstream f (text);
if (!f) {
cout << “Ошибка открытия файла”;
return 1;
}
while (!f.eof ()) {
f.getline (buf,81);
cout << buf << endl;
}
return 0;
}
Для закрытия потока определен метод close (), но поскольку он неявно выполняется деструктором, явный вызов необходим только тогда, когда требуется закрыть поток раньше конца его области видимости.
Задание
Перепишите вашу программу – телефонный справочник с использованием файловых потоков и форматированного ввода-вывода.
Строковые потоки
Строковые потоки позволяют считывать и записывать информацию из областей оперативной памяти так же, как и из файла, с консоли или на дисплей. В стандартной библиотеке определено три класса строковых потоков:
istringstream – входные строковые потоки;
ostringstream – выходные строковые потоки;
stringstream – двунаправленные строковые потоки.
Эти классы определены в заголовочном файле <sstream> и являются производными от классов istream, ostream и iostream соответственно.
Участки памяти, с которыми выполняются операции чтения и извлечения, по стандарту определяются как строки С++ (класс string). Строковый класс будет рассмотрен далее. Строковые потоки создаются и связываются с этими участками памяти с помощью конструкторов:
explicit istringstream (int mode = ios:: in);
explicit istringstream (const string & name, int mode = ios:: in);
explicit ostringstream (int mode = ios:: out);
explicit ostringstream (const string & name, int mode = ios:: out);
explicit stringstream (int mode = ios:: in | ios:: out);
explicit stringstream (const string & name, int mode = ios:: in | ios:: out);
Здесь слово explicit указывает на то, что эти конструкторы вызываются только явным образом.
В строковых потоках описан метод str, возвращаюший копию строки или устанавливающий ее значение:
string str () const;
void str (const string & S);
Пример. Строковый поток используется для формирования сообщения, включающего текущее время и передаваемый в качестве параметра номер:
# include <sstream>
# include <string>
# include <iostream>
# include <ctime>
using namespace std;
string message (int i) {
ostringstream os;
time_t t;
time (&t); // Функция возвращает текущие дату и время в виде time_t
os << “time: “ << ctime (&t) <<”number: ” << i << endl;
return os.str (); // Функция ctime () превращает время
// в строку
}
int main () {
cout << message (22);
return 0;
}
Строки
С++ не содержит стандартного типа данных “строка”. Вместо этого он поддерживает массивы символов, завершающиеся нуль-символом. Библиотека содержит функции для работы с такими массивами, унаследованные от С и описанные в заголовочном файле <string.h>.
Тип данных (класс) string стандартной библиотеки лишен недостатков, присущих массивам символов. Основные действия со строками выполняются в нем с помощью операций и методов, а длина строки изменяется динамически. Для использования класса необходимо подключать к программе заголовочный файл <string>.