Флаги и форматирующие методы

ВВЕДЕНИЕ

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

Классы стандартной библиотеки можно разделить на следующие группы.

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

Строковый класс – предназначены для работы с символьными переменными.

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

Итераторы – предназначены для унифицированного доступа к элементам классов.

Математические классы – поддерживают обработку массивов с плавающей точкой и работу с комплексными числами.

Диагностические классы – обеспечивают динамическую идентификацию типов и объектно-ориентированную обработку ошибок.

Остальные классы обеспечивают динамическое распределение памяти и ряд других функций.

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

Потоковые классы

Поток – это абстрактное понятие, относящееся к любому переносу данных от источника к приемнику.

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

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

По виду устройств, с которыми работает поток, можно выделить стандартные, файловые и строковые потоки.

Стандартные потоки предназначены для передачи данных от клавиатуры и на экран.

Файловые потоки – для обмена информацией с файлами на внешних устройствах.

Строковые потоки – для работы с массивами символов.

Для поддержки потоков библиотека С++ содержит иерархию классов, построенную на основе двух базовых классов – 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>.

Наши рекомендации