качестве единственного параметра строку 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 outputn";

  cout << "this function does really heavy workn";

  cout << "...and lots of it...n";

  // ...

}

7. В функции main сначала создадим совершенно обычные выходные данные:

int main()

{

  cout << "Readable from normal stdoutn";

8. Теперь откроем еще одну область видимости, и первое, что мы в ней сделаем, — создадим экземпляр нового класса с параметром в виде текстового файла.

Файловые потоки открывают файлы в режиме чтения и записи по умолчанию, поэтому создадут для нас данный файл. Любые выходные данные будут перенаправлены в него, однако для вывода данных мы используем cout:

  {

    redirect_cout_region _ {"output.txt"};

    cout << "Only visible in output.txtn";

    my_output_heavy_function();

  }

9. После того как мы покинем область видимости, файл будет закрыт и выходные данные станут перенаправляться в стандартный поток вывода. Теперь откроем еще одну область видимости, в которой создадим экземпляр того же класса с помощью конструктора по умолчанию. Таким образом, следующая строка нигде не будет видна, она просто отбросится:

  {

    redirect_cout_region _;

    cout << "This output will "

            "completely vanishn";

  }

10. После того как мы покинем эту область видимости, стандартный поток вывода восстановится и последнюю строку можно будет увидеть на консоли.

  cout << "Readable from normal stdout againn";

}

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 outputn";

  redirect_cout_region la {"a.txt"};

  cout << "print to a.txtn";

  redirect_cout_region lb {"b.txt"};

  cout << "print to b.txtn";

}

cout << "print to standard output againn";

Этот код работает, поскольку объекты разрушаются в порядке, обратном порядку их создания. Концепция, лежащая в основе данного шаблона, который использует тесное связывание между созданием и разрушением объектов, называется «Получение ресурса есть инициализация» (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 очень полезен. Однако, как только пользователям нужен строковый класс, семантика которого несколько отличается от обычной обработки строк, они пишут собственный класс string. Такая идея редко хороша, поскольку не так просто безопасно обработать строки. К счастью, класс std::string — лишь специализированное ключевое слово шаблонного класса std::basic_string. Данный класс содержит все сложные средства обработки памяти, но не навязывает никаких правил, как копировать строки, сравнивать их и т.д. Эти правила импортируются в basic_string, для чего принимается шаблонный параметр, который содержит класс traits.

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

Как это делается

В этом примере мы реализуем два разных пользовательских строковых класса: lc_string и ci_string. Первый создает на основе любых входных данных строки в нижнем регистре. Второй строки не преобразует, но может выполнить сравнение строк независимо