по умолчанию:
#include
#include
using namespace std;
2. Реализуем класс, содержащий объект файлового потока и указатель на буфер потока.
cout
, представленный как объект потока, имеет внутренний буфер, который можно подменить. В процессе выполнения подобной подмены можно сохранить его исходное состояние, чтобы в будущем иметь возможность отменить это изменение. Мы могли бы найти его тип в справочном материале по С++, но также можем использовать decltype
, чтобы узнать, какой тип возвращает конструкция cout.rdbuf()
. Данный прием подходит не для всех ситуаций, но в нашем случае мы получим тип указателя:
class redirect_cout_region
{
using buftype = decltype(cout.rdbuf());
ofstream ofs;
buftype buf_backup;
3. Конструктор нашего класса принимает в качестве единственного параметра строку
filename
. Данная строка используется для инициализации члена файлового потока ofs
. После этого можно передать его в cout
в качестве нового буфера потока. Та же функция, что принимает новый буфер, также возвращает указатель на старый, поэтому можно сохранить его, чтобы в будущем восстановить.
public:
explicit
redirect_cout_region (const string &filename)
: ofs{filename},
buf_backup{cout.rdbuf(ofs.rdbuf())}
{}
4. Конструктор по умолчанию делает то же, что и предыдущий конструктор. Различие заключается вот в чем: он не открывает никаких файлов. Передача созданного по умолчанию буфера файлового потока в поток
cout
приводит к тому, что cout
в некотором роде деактивизируется. Он просто будет отбрасывать входные данные, что мы ему передаем. Это также может быть полезно в отдельных ситуациях.
redirect_cout_region()
: ofs{},
buf_backup{cout.rdbuf(ofs.rdbuf())}
{}
5. Деструктор просто отменяет наше изменение. Когда объект этого класса выходит из области видимости, буфер потока
cout
возвращается в исходное состояние:
~redirect_cout_region() {
cout.rdbuf(buf_backup);
}
};
6. Создадим функцию, генерирующую множество выходных данных, чтобы с ней можно было работать в дальнейшем:
void my_output_heavy_function()
{
cout << "some output\n";
cout << "this function does really heavy work\n";
cout << "...and lots of it...\n";
// ...
}
7. В функции
main
сначала создадим совершенно обычные выходные данные:
int main()
{
cout << "Readable from normal stdout\n";
8. Теперь откроем еще одну область видимости, и первое, что мы в ней сделаем, — создадим экземпляр нового класса с параметром в виде текстового файла.
Файловые потоки открывают файлы в режиме чтения и записи по умолчанию, поэтому создадут для нас данный файл. Любые выходные данные будут перенаправлены в него, однако для вывода данных мы используем cout:
{
redirect_cout_region _ {"output.txt"};
cout << "Only visible in output.txt\n";
my_output_heavy_function();
}
9. После того как мы покинем область видимости, файл будет закрыт и выходные данные станут перенаправляться в стандартный поток вывода. Теперь откроем еще одну область видимости, в которой создадим экземпляр того же класса с помощью конструктора по умолчанию. Таким образом, следующая строка нигде не будет видна, она просто отбросится:
{
redirect_cout_region _;
cout << "This output will "
"completely vanish\n";
}
10. После того как мы покинем эту область видимости, стандартный поток вывода восстановится и последнюю строку можно будет увидеть на консоли.
cout << "Readable from normal stdout again\n";
}
11. Компиляция и запуск программы дадут следующий ожидаемый результат. На консоли будут видны только первая и последняя строки:
$ ./log_regions
Readable from normal stdout
Readable from normal stdout again
12. Можно увидеть, что был создан новый файл
output.txt
, который содержит выходные данные, полученные из первой области видимости. Выходные данные, полученные из второй области видимости, пропали без следа:
$ cat output.txt
Only visible in output.txt some output
this function does really heavy work
... and lots of it...
Как это работает
Каждый объект потока имеет внутренний буфер, для которого он играет роль фронтенда. Такие буферы взаимозаменяемы. Если у нас есть объект потока
s
, а мы хотим сохранить его буфер в переменную a
и установить новый буфер b
, то данная конструкция будет выглядеть так: a = s.rdbuf(b)
. Восстановить буфер можно следующим образом: s.rdbuf(a)
.Именно это мы и сделали в данном примере. Еще один положительный момент заключается в том, что можно объединять эти вспомогательные функции
redirect_ cout_region
:
{
cout << "print to standard output\n";
redirect_cout_region la {"a.txt"};
cout << "print to a.txt\n";
redirect_cout_region lb {"b.txt"};
cout << "print to b.txt\n";
}
cout << "print to standard output again\n";
Этот код работает, поскольку объекты разрушаются в порядке, обратном порядку их создания. Концепция, лежащая в основе данного шаблона, который использует тесное связывание между созданием и разрушением объектов, называется «Получение ресурса есть инициализация» (resource acquisition is initialization, RAII).
Следует упомянуть еще один очень важный момент — обратите внимание на порядок инициализации переменных-членов класса
redirect_cout_region
:
class redirect_cout_region {
using buftype = decltype(cout.rdbuf());
ofstream ofs;
buftype buf_backup;
public:
explicit
redirect_cout_region(const string &filename)
: ofs{filename},
buf_backup{cout.rdbuf(ofs.rdbuf())}
{}
...
Как видите, член
buf_backup
создается из выражения, которое зависит от ofs
. Очевидно, это значит следующее: ofs
нужно инициализировать до buf_backup
. Что интересно, порядок, в котором инициализируются переменные-члены, не зависит от порядка элементов списка инициализаторов. Порядок инициализации зависит только от порядка объявления членов!
Если одна переменная-член должна быть инициализирована после другой переменной, то их нужно привести именно в этом порядке при объявлении членов класса. Порядок их появления в списке инициализаторов конструктора некритичен.
Создаем пользовательские строковые классы путем наследования std::char_traits
Класс
std::string
очень полезен. Однако, как только пользователям нужен строковый класс, семантика которого несколько отличается от обычной обработки строк, они пишут