Форматирование ввода вывода

специальные форматные флаги, другой – их настройка под национальные стандарты.
Класс

ios_base содержит ряд переменных, предназначенных для определения форматов ввода-вывода. В частности, эти переменные определяют минимальную ширину поля, точность вывода вещественных чисел и заполнитель. Переменная типа ios::fmtflags содержит флаги конфигурации, которые определяют, нужно ли выводить знак перед положительными числами, должны ли логические значения выводиться в числовом или символьном виде и т.д.
Некоторые форматные флаги составляют группы. Определены специальные маски, упрощающие работу с группами.
Имеются три стандартные маски:

adjustfield = internal | left | right
basefield = dec | oct | hex
floatfield = fixed | scientific

при помощи пары манипуляторов:
setiosflags(флаги) – установка передаваемых флагов
resetiosflags(маска) – сброс

флагов, определяемых передаваемой маской.

Манипуляторы setiosflags() и resetiosflags() дают возможность соответственно установить или сбросить один или несколько флагов в командах записи или чтения с использованием оператора << или >>.

#include
#include
. . .
std::cout << resetiosflags(std::ios::adjustfield) ; // Сброс выравнивания
std::cout << setiosflags(std::ios::left) ; // Левое выравнивание

логических значений – числовой или текстовый. Если флаг не установлен

(значение по умолчанию), логические данные представляются в числовом виде. В этом случае false всегда представляется значением О, а true -значением 1. При чтении логических данных в числовом представлении наличие символов, отличных от О и 1, считается ошибкой (для потока данных устанавливается бит failbit).
При установке флага логические данные читаются и записываются в тексто-вом представлении. При чтении логического значения строка должна соответ-ствовать текстовому представлению true или false. Строки, представляющие эти значения, определяются состоянием объекта локального контекста.
Стандартный объект локального контекста "С" использует для представления
логических значений строки "true" и "false". Для удобства работы с этим флагом определены специальные манипуляторы:
boolalpha Включает текстовое представление (установка флага ios::boolalpha)
noboolalpha Включает числовое представление (сброс флага ios::boolalpha)
Следующий фрагмент выводит переменную b сначала в числовом, а затем в текстовом представлении:
bооl b;
. . .
cout << noboolalpha << b << " " << boolalpha << b << endl;

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

аргументов width() возвращает текущую ширину поля. При вызове с целочисленным аргументом функция width() изменяет ширину поля и возвращает ее предыдущее значение.
Ширина поля не может использоваться для сокращения вывода. То есть максимальную ширину поля задать невозможно. Вместо этого ее придется самостоятельно запрограммировать, например, записав данные в строку и ограничив вывод определенным количеством символов.
По умолчанию минимальная ширина равна 0; это означает, что размер поля может быть произвольным.

После выполнения любой операции форматированного ввода-вывода восстанавливается ширина поля по умолчанию.

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

заполнителем является пробел.
Заполнитель остается без изменений до тех пор, пока он не будет модифицирован явно.

таблице. Эти флаги определяются в классе ios_base вместе с соответствующей

маской.

Заполнитель остается без изменений до тех пор, пока он не будет модифицирован явно.

Заполнитель – знак подчеркивания, ширина поля - 6
-53 0.12 sss

left -53___ 0.12___ sss___
right ___-53 ___0.12 ___sss
internal -___53 ___0.12 ___sss

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

файл .

std::setfill('_')

<< ' ' << 42 << std::endl;
std::cout << std::setw(8) << "sum: " << std::setw(8) << 42 << std::endl;


Этот фрагмент выводит следующий результат:
___-3.14 42
____sum: ______42

количество символов, вводимых при чтении последовательностей символов типа char*. Если

значение width() отлично от 0, то из потока данных читаются не более, width() -1 символ.
Поскольку обычные С-строки не могут увеличиваться при чтении данных, при их чтении оператором >> всегда следует ограничивать максимальный размер ввода функциями width() или setw(). Пример:
char buffer[81]: // Чтение не более 80 символов
cin >> setw(sizeof(buffer)) >> buffer;

Функция читает не более 80 символов, хотя sizeof(buffer) возвращает 81, поскольку один символ является признаком завершения строки (он присоеди-няется автоматически). Обратите внимание на распространенную ошибку:
char* s:
cin >> setw(sizeof(s)) >> s: // ОШИБКА ВРЕМЕНИ ВЫПОЛНЕНИЯ

Строковые классы позволяют предотвратить подобные ошибки:
string buffer:
cin >> buffer: // ОК

числа должны выводиться со знаком.
Если флаг сброшен, то со

знаком выводятся только отрицательные числа.
По умолчанию положительные числа выводятся без знака.
Установка и сброс флага может быть осуществлен при помощи манипуляторов showpos и noshowpos соответственно.
std::cout << 123.9 << std::endl;
std::cout.setf (std::ios::showpos);
std::cout << 123.9 << std::endl;
Этот фрагмент выводит следующий результат:
123.9
+123.9

используемой при вводе-выводе целых чисел. Флаги определяются в классе ios_base

вместе с соответствующей маской.

Смена основания системы счисления отражается на дальнейшем вводе-выводе всех целых чисел до следующего изменения флагов. По умолчанию используется десятичный формат.
Поддержка двоичной записи не предусмотрена, однако чтение и запись целых чисел в двоичном виде может осуществляться при помощи класса bitset.
Флаги системы счисления также распространяются на ввод. Данные читаются в системе, определяемой установкой одного из флагов. Если флаги не установлены, то при чтении основание системы счисления определяется по префиксу: 0х или 0Х - интерпретируется как шестнадцатеричное; префикс 0 является признаком восьмеричной записи.
Во всех остальных случаях число считается десятичным.

Сброс одного флага и установка другого:
std::cout.unsetf (std::ios::dec);

std::cout.setf (std::ios::hex);
Установка одного флага с автоматическим сбросом остальных флагов группы:
std::cout.setf(std::ios::hex, std::ios::basefield);

Для удобства программирования существуют и специальные манипуляторы oct, hex и dec:

int х, у, z;
std::cout << std::ios::hex << х << std::endl;
std::cout << у << ' ' << std::ios:dec << z << std::endl;

Этот фрагмент выводит х и у в 16-ой, а z - в 10-ой системе.

обозначения системы счисления числовых литералов в С/С++.
При установке флага ios::showbase

восьмеричные числа выводятся с префиксом 0, а шестнадцатеричные числа - с префиксом 0х (или при установленном флаге ios::uppercase - 0Х).
Установка и сброс флага ios::showbase может быть выполнена с использованием специальных манипуляторов showbase и noshowbase.

std::cout << 127 << ' ' <<255<< std::endl;
std::cout << std::hex <<127 << ' ' <<255 << std::endl;
std::cout.setf(std::ios::showbase);
std::cout << 127 << ' ' << 255 << std::endl;
std::cout.setf(std::ios::uppercase);
std::cout << 127 << ' ' << 255 << std::endl;

Этот фрагмент выводит следующий результат:

127 255
7f ff
0x7f 0xff
0X7F 0XFF

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

на целые числа, записанные в шестнадцатеричном виде, так и на вещественные числа в научной (экспоненциальной) записи.
По умолчанию символы выводятся в нижнем регистре.
Установка и сброс флага может быть осуществлен при помощи манипуляторов uppercase и nouppercase соответственно.

std::cout <<(std::hex) << 0xabc << ' ' << 1.2
<< ' ' << (std::scientific) << 1.2 << std::endl;
std::cout.setf (std::ios::uppercase);
std::cout << 0xabc << ' ' << 1.2 << std::endl;
Результат:
abc 1.2 1.200000e+000
ABC 1.2 1.200000E+000

Флаги, перечисленные в таблице, определяют тип записи (десятичная или научная).

Эти флаги определяются в классе ios_base вместе с соответствую-щей маской.

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

ios::fixed и ios::scientific не установлен. В этом случае запись выбирается

в зависимости от выводимого значения.
Для этого делается попытка вывести все значащие десятичные цифры (но не более precision()) с удалением начального нуля перед десятичной точкой и/или всех завершающих пробелов, а в крайнем случае - даже десятичной точки. Если precision() разрядов оказывается достаточно, используется десятичная запись; в противном случае - научная запись.

При помощи флага showpoint можно заставить поток данных выводить десятичную точку и завершающие нули до ширины precision() разрядов

ios::showpos служит для принудительного вывода знака положительных чисел.
Флаг ios::uppercase

указывает, какая буква должна использоваться в научной записи (Е или е).

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

чтении данных оператором >>.
Флаг ios::skipws устанавливается по умолчанию; это

означает, что по умолчанию некоторые операции чтения игнорируют начальные пропуски. Обычно этот флаг удобнее держать установленным. Например, вам не придется специально заботиться о чтении пробелов, разделяющих числа. С другой стороны, это означает, что вы не сможете читать пробелы оператором >>, потому что начальные пропуски всегда игнорируются.
Для управления этим флагом существуют манипуляторы skipws (установка) и noskipws (сброс).

unitbuf – флаг принудительного вывода содержимого буфера после каждой операции записи.
Флаг ios::unitbuf управляет буферизацией вывода. При установленном флаге ios::unitbuf вывод практически выполняется без буферизации – выход-ной буфер очищается после каждой операции записи. По умолчанию этот флаг не устанавливается. Исключение составляют потоки данных cerr и wcerr, для которых этот флаг устанавливается в исходном состоянии.
Для управления этим флагом существуют манипуляторы unitbuf (установка) и nounitbuf (сброс).

цели определены в классе ios_base. imbue(loc) - назначение объекта локального

контекста.
getloc() - получение текущего объекта локального контекста.
С каждым потоком данных связывается некоторый объект локального контекста. По умолчанию исходный объект локального контекста создается как
копия глобального объекта локального контекста на момент конструирования
потока данных. В частности, объект локального контекста определяет параметры форматирования чисел (например, символ, используемый в качестве десятичной точки, или режим числового/строкового представления логических величин).
В отличие от аналогичных средств С средства интернационализации стандартной библиотеки С++ позволяют задавать локальные контексты на уровне отдельных потоков данных. Например, такая возможность позволяет выполнять чтение вещественных чисел в американском формате и последующей записи в немецком формате (в котором вместо «десятичной точки» используется запятая).

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

Для этого в потоках данных поддерживаются функции преобразования:
widen(c) – преобразование символа с типа char к кодировке, используемой потоком.
narrow(c,def) – преобразование символа с из кодировки, используемой потоком, к типу char (если такого символа не существует, возвращается def).

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

strm.widen('\n');

В стандартную библиотеку С++ входят четыре основных шаблона, для которых

определены стандартные специализации.
Шаблон basic_ifstream< > со специализациями ifstream и wifstream обеспечивает чтение файлов («файловый входной поток данных»).
Шаблон basic_ofstream< > со специализациями ofstream и wofstream обеспечивает запись файлов («файловый выходной поток данных»).
Шаблон basic_fstream< > со специализациями fstream и wfstream обеспечивает чтение и запись файлов.
Шаблон basic_filebuf< > со специализациями filebuf и wfilebuf используется только другими классами файловых потоков данных для выполнения фактических операций чтения и записи символов.

/ wistream
basic_ostream ostrеаm / wostream
basic_iostream
iostream / wiostream
(virtual)
basic_filebuf
filebuf / wfilebuf
basic_ifstream ifstrеаm

/ wifstream

basic_ofstream<> ofstrеаm / wofstream

basic_fstream<>
fstream / wfstream

charT, class traits = char traits >
class basic_ifstream;
typedef basic_ifstream

ifstream;
typedef basic_ifstream wifstream;
template >
class basic_ofstream;
typedef basic_ofstream ofstream;
typedef basic_ofstream wofstream;
template >
class basic_fstream;
typedef basic_fstream fstream;
typedef basic_fstream wfstream;
template >
class basic_filebuf;
typedef basic_filebuf filebuf:
typedef basic_filebuf wfilebuf;
}

является
автоматизация выполняемых операций. Файлы автоматически открываются во
время конструирования и закрываются

при уничтожении объекта. Естественно, что эта возможность имеется благодаря соответствующему определению конструкторов и деструкторов.
Одно важное обстоятельство, относящееся к потокам данных с поддержкой
и чтения и записи, - такие потоки не должны допускать произвольного переключения между чтением и записью!! Чтобы после начала чтения из файла переключиться на запись (или наоборот), необходимо выполнить операцию позиционирования (возможно, с сохранением текущей позиции). Единственное исключение из этого правила относится к чтению с выходом за конец файла; в этой ситуации можно немедленно переходить к записи символов. Нарушение
этого ограничения приводит к нежелательным побочным эффектам.
Если при конструировании файлового потока данных в аргументе передается С-строка (тип char*), то при этом автоматически делается попытка открыть
файл для чтения и/или записи. Признак успеха этой попытки отражается в состоянии потока данных. Следовательно, после конструирования следует проверить состояние потока данных.

ввод-вывод
#include / / setw()
#include / / exit()
using namespace std;

// Опережающие

объявления
void writeCharsetToFile (const string& filename);
void outputFile (const string& filename);

int main ()
{
wri teCharsetToFi lе( "charset. out") ;
outputFile("charset.out");
}

Создание файла, содержащего весь набор символов (символы от 32 до 255)

Открытие выходного файла
ofstream file(filename.c_str());
// Файл открыт?
if (! file)

{
// NO. abort program
cerr << "can't ореп output file \"" << filename << "\"" << endl;
exit(EXIT_FAILURE);
}
// Вывод текущего набора символов
for (int i=32; i <256; i++) {
file << "value: " << setw(3) << i << " "
<< "char: " << static_cast(i) << endl;
}
} // Автоматическое закрытие файла

Создание файла, содержащего весь набор символов (символы от 32 до 255)

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

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

std::ofstream* fileptr = new std::ofstream(“xyz");
delete fileptr;

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

std::cout << file.rdbuf();

ios_base. Флаги относятся к типу openmode и группируются в битовые

маски по аналогии с флагами fmtflags.

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

символьных последовательностей (например, конца строки или конца файла). В операционных

системах типа MS-DOS или OS/2 конец логической строки в тексте обозначается двумя символами (CR и LF). При открытии файла в обычном текстовом режиме (сброшенный флаг binary) символы новой строки заменяются последовательностью из двух символов, и наоборот. При открытии файла в двоичном режиме (с установленным флагом binary) эти преобразования не выполняются.
Флаг binary должен использоваться всегда, когда файл не содержит чисто текстовой информации и обрабатывается как двоичные данные. Пример – копи-рование файла с последовательным чтением символов и их записью без моди-фикации. Если файл обрабатывается в текстовом виде, флаг binary не устанав-ливается, потому что в этом случае символы новой строки нуждаются в специ-альной обработке. Флаги объединяются оператором 1. Полученный результат типа openmode может передаваться конструктору во втором аргументе.
Cледующая команда открывает файл для присоединения текста в конце:
std::ofstream file("abc.out", std::ios::out | std::ios::арр);

строке с присоединенным символом b, а установленный флаг ate соответствует

позиционированию в конец файла немедленно после открытия. Другие комбинации, отсутствующие в таблице (например, trunc l app), недопустимы.

зависит от класса соответствующего объекта потока данных. Класс лишь определяет

режим открытия по умолчанию при отсутствии второго аргумента. Это означает, что файлы, используемые только классом ifstream или ofstream, могут открывать-ся для чтения u записи. Режим открытия передается соответствующему классу потокового буфера, который открывает файл. Тем не менее операции, разрешенные для данного объекта, определяются классом потока данных.
Для открытия и закрытия файлов, принадлежащих файловым потокам данных, существуют функции :

ореn(имя) – открытие файла для потока в режиме по умолчанию;
ореn(имя, флаги) – открытие файла для потока в режиме, определяемом переданными флагами;
close() – закрытие файлового потока;
is_open() – проверка открытия файла.

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

#include
using namespace std;
/* Для всех файлов. имена которых переданы

в аргументах командной строки.
* - открыть. вывести содержимое и закрыть файл
*/

void main (int argc, char* argv[])
{
ifstream file;
// Перебор аргументов командной строки
for (int i=1; i// Открытие файла
file.open(argv[i]);

char c;
while (file.get(c)) {

cout.put(c);
}

// Сброс флагов eofbit и failbit. установленных
// при обнаружении конца файла (open ничего такого не делает!!!)
file.clear();

// Закрытие файла
file.close();

} // На следующий файл из списка аргументов программы

}

номера)
2) Что будет выведено на экран в результате компиляции и

выполнения следующего кода?

#include
using namespace std;
struct A {
A() { cout << "A"; }
~A() { cout << "~A"; }
virtual void operator()() = 0;
};
struct B : A {
B() { cout << "B"; }
~B() { cout << "~B"; }
void operator()() { cout << "B"; }
};
int main(void) {
B b; //AB
A &a = b; //B
a();
b(); //B
return 0; //~B~A
}

3) Какой тип имеет такой литерал: "C++" ?

(1) char[4]
(2) char[3]
(3) const char[4]
(4) Ничего из перечисленного
(5) const char[3]