Fstream c описание: Потоковый ввод-вывод в файлы

Наиболее часто применяются классы ifstream для чтения, ofstream для записи и fstream для модификации файлов.

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

Ниже приведены возможные значения флагов и их назначение.

Например, чтобы открыть файл с именем test.txt для чтения данных в бинарном виде, следует написать:

Оператор логического ИЛИ ( | ) позволяет составить режим с любым сочетанием флагов. Так, чтобы, открывая файл по записи, случайно не затереть существующий файл с тем же именем, надо использовать следующую форму:

Предполагается, что к проекту подключён соответствующий заголовочный файл:

Для проверки того удалось ли открыть файл, можно применять конструкцию

Операторы включения и извлечения

Переопределённый в классах работы с файлами

Можно также записывать текстовую строку по частям:

Оператор endl завершает ввод строки символом «возврат каретки»:

С помощью оператора включения несложно записывать в файл значения переменных или элементов массива:

В результате выполнения кода образуется три строки текстового файла Temp.txt :

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

Оператор извлечения ( >> )производит обратные действия. Казалось бы, чтобы извлечь символы из файла Temp.txt , записанного ранее, нужно написать код наподобие следующего:

Однако оператор извлечения остановится на первом попавшемся разделителе (символе пробела, табуляции или новой строки). Таким образом, при разборе предложения «Текстовый массив содержит переменные» только слово «Текстовый» запишется в массив buff , пробел игнорируется, а слово «массив» станет значением целой переменной vx и исполнение кода «пойдет вразнос» с неминуемым нарушением структуры данных. Далее, при обсуждении класса ifstream , будет показано, как правильно организовать чтение файла из предыдущего примера.

Класс ifstream: чтение файлов

Как следует из расшифровки названия, класс ifstream предназначен для ввода файлового потока. Далее перечислены основные методы класса. Большая часть из них унаследована от класса istream и перегружена с расширением родительской функциональности. К примеру, функция get , в зависимости от параметра вызова, способна считывать не только одиночный символ, но и символьный блок.

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

Метод getline прочитает первую строку файла до конца, а оператор >> присвоит значения переменным.

Следующий пример показывает добавление данных в текстовый файл с последующим чтением всего файла. Цикл while (1) используется вместо while(!file2.eof()) по причинам, которые обсуждались в предыдущей лекции.

В следующем примере показан цикл считывания строк из файла test.txt и их отображения на консоли.

Этот код под ОС Windows также зависит от наличия в последней строке файла символа перевода строки, надежнее было бы сделать так:

Явные вызовы методов open и close не обязательны. Действительно, вызов конструктора с аргументом позволяет сразу же, в момент создания поточного объекта file , открыть файл:

Вместо метода close можно использовать оператор delete , который автоматически вызовет деструктор объекта file и закроет файл. Код цикла while обеспечивает надлежащую проверку признака конца файла.

Класс ofstream: запись файлов

Класс ofstream предназначен для вывода данных из файлового потока. Далее перечислены основные методы данного класса.

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

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

Первый параметр методов write и read (адрес блока записи/чтения) должен иметь тип символьного указателя char * , поэтому необходимо произвести явное преобразование типа адреса структуры void * . Второй параметр указывает, что бинарные блоки файла имеют постоянный размер байтов независимо от фактической длины записи. Следующее приложение дает пример создания и отображения данных простейшей записной книжки. Затем записи файла последовательно считываются и отображаются на консоли.

В результате выполнения этого кода образуется бинарный файл Notebook.dat из трех блоков размером по 80 байт каждый (при условии, что символы – однобайтовые). Естественно, вы можете использовать другие поточные методы и проделывать любые операции над полями определенной структуры данных.

Класс fstream: произвольный доступ к файлу

Предположим что в нашей записной книжке накопилось 100 записей, а мы хотим считать 50-ю. Конечно, можно организовать цикл и прочитать все записи с первой по заданную. Очевидно, что более целенаправленное решение – установить указатель позиционирования файла pos прямо на запись 50 и считать ее:

Подобные операции поиска эффективны, если файл состоит из записей известного и постоянного размера. Чтобы заменить содержимое произвольной записи, надо открыть поток вывода в режиме модификации:

Если не указать флаг ios::ate (или ios::app ), то при открытии бинарного файла Notebook.dat его предыдущее содержимое будет стерто!

Наконец, можно открыть файл одновременно для чтения/записи, используя методы, унаследованные поточным классом fstream от своих предшественников. Поскольку класс fstream произведен от istream и ostream (родителей ifstream и ofstream соответственно), все упомянутые ранее методы становятся доступными в приложении.

В следующем примере показана перестановка первой и третьей записей файла Notebook.dat .

В конструкторе объекта file надо указать флаги ios::in и ios::out , разрешая одновременное выполнение операций чтения и записи. В результате выполнения этого кода первая и третья записи бинарного файла Notebook.dat поменяются местами.

Дополнительные примеры по теме есть в этой заметке.

Оглавление серии

05.11.2015, 09:45; рейтинг: 103621

Привет я c++ начинающий, и это одно из моих заданий, и я немного застрял. Это не весь мой код, это всего лишь фрагмент того, с чем мне нужна помощь. То, что я пытаюсь сделать, это иметь одну функцию, предназначенную для экспорта всего с этой функцией в text файл, который называется results.txt. Поэтому строка «делает эту работу» должна отображаться, когда я открываю файл, но когда я запускаю файл, я получаю такие ошибки, как

«Ошибка C2065:« out »: необъявленный идентификатор»

«Ошибка C2275:« std :: ofstream »: незаконное использование этого типа в качестве выражения»

«IntelliSense: имя типа не допускается»

«IntelliSense: идентификатор» out «не определен»

Сейчас очень поздно, и я просто не понимаю, что делаю не так.

Решение

Прежде всего, это хорошо:

Однако это не так:

Это первая ошибка, которую вы получите: «Ошибка C2065:« out »: необъявленный идентификатор», потому что компилятор еще не знает об этом.

Во втором фрагменте вы хотите вызов выход с определенным ostream& , Вместо вызова функции вы даете объявление функции, что не разрешено в этом контексте. Вы должны назвать это с учетом ostream& :

В этом случае вы вызов output с out в качестве параметра.

Другие решения

Поскольку вы описали себя как начинающего, я отвечу соответственно и, надеюсь, в образовательной форме. Вот что происходит: подумайте о fstream , ofstream а также ifstream как умные типы переменных (даже если вы знаете, что такое классы, подумайте об этом ради логическая ясность). Как и любая другая переменная, вы должны объявить это прежде чем использовать. После того, как объявлено, эта переменная может держать совместимое значение. fstream типы переменных для хранение файлов. Все его вариации содержат одно и то же, но то, что они делают, отличается.

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

• atomic (C++11)
• condition_variable (C++11)
• future (C++11)
• mutex (C++11)
• shared_mutex (C++14)
• thread (C++11)

• cassert
• cctype
• cerrno
• cfenv (C++11)
• cfloat
• cinttypes (C++11)
• ciso646
• climits
• clocale
• cmath
• csetjmp
• csignal
• cstdarg
• cstdbool (C++11)
• cstddef
• cstdint (C++11)
• cstdio
• cstdlib
• cstring
• ctgmath (C++11)
• ctime
• cuchar (C++11)
• cwchar
• cwctype

fstream (сокращение от «FileStream») — заголовочный файл из стандартной библиотеки C++, включающий набор классов, методов и функций, которые предоставляют интерфейс для чтения/записи данных из/в файл. Для манипуляции с данными файлов используются объекты, называемые потоками («stream»).

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

Общедоступные функции [ править | править код ]

Это корневые функции библиотеки, не вошедшие ни в один из основных классов. Они используются довольно часто и могут быть применимы ко всем объектам потоков в каждом из классов.

• rdbuf . Все объекты fstream могут быть ассоциированы с объектом буфера файлов filebuf . Чтобы сопоставить объект класса fstream с объектом буфера, используют функцию rdbuf (без аргументов). Объект буфера предоставляет намного большие возможности по управлению данными в файле, чем стандартные функции подклассов fstream .

• open() . Этим методом можно открыть заданный файл, сопоставив его с одним из объектов потока[1]. В зависимости от передаваемых аргументов, файл может быть открыт для чтения, для записи (либо для полной, либо для добавления данных), как бинарный, или как текстовый файл.

• is_open() . Функция, определяющая, открыт ли в данный момент файл, которому сопоставлен определенный объект потока. Возвращает булевское значение. Используется в основном для предотвращения ошибок доступа при попытке открыть уже использующийся файл. Без аргументов.

• close() . Функция закрывает файл, то есть прекращает доступ к нему, таким образом освобождая его для других функций или программ.

Привет, std::filesystem!. Небольшой пост о больших возможностях… | by Sergey Shambir

Небольшой пост о больших возможностях C++17

Как попробовать filesystem

На момент написания поста, то есть в июне 2017 года, стандарт С++17 ещё не утверждён окончательно, поэтому пространство имён filesystem целиком находится в std::exprimental. Три ведущих компилятора уже реализовали filesystem:

• Для Visuals Studio данный модуль доступен начиная с VS2017, и не забудьте включить в своих проектах флаг “/std:c++latest”
• Для Clang/LLVM с библиотекой libc++ модуль также доступен, но не забудьте добавить к флагам компоновщика -lc++experimental -pthread, поскольку в этой реализации STL все экспериментальные возможности выделены в “libc++experimental.a”, а сама STL использует pthreads
• Для компилятора G++ из состава GCC версии 6.x и выше также потребуется флаг компоновщика: -lstdc++fs.

В любом случае, вам потребуется включать <std/experimental/filesystem> вплоть до окончательного вступления C++17 в силу.

Конструирование путей и работа с кодировками

Любой опытный программист знает о разнице в обработке путей между Windows и UNIX-системами:

• в Windows пути принимаются в виде UTF-16 строк, часто используемый тип wchar_t представляет 2-байтный символ в кодировке UTF-16, а разделителем путей служит обратный слеш “\”
• в UNIX пути принимаются в виде UTF-8 строк, редко используеый wchar_t представляет 4-байтный символ в кодировке UCS32, а разделителем путей служит прямой слеш “/”

Конечно же filesystem абстрагируется от подобных различий и позволяет легко работать как с платформо-зависимыми строками, так и с универсальным UTF-8. Для получения UTF-8 версии пути служит метод .u8string().

Другие методы path и свободные функции позволяют конвертировать относительные пути в абсолютные и обратно, заменять расширение или имя файла, нормализовывать разделители к родному для ОС формату или получать “каноническое” представление пути.

Создание, удаление, переименование, копирование

Модуль filesystem предоставляет средства

• для проверки существования файла или каталога по заданному пути: fs::exists
• для создания каталога (даже если потребуется создать несколько вложенных каталогов, он с этим справится): fs::create_directories
• для удаления каталогов и файлов: fs::remove (удаляет файл или пустой каталог) и fs::remove_all (удаляет файл или рекурсивно удаляет каталог)
• для копирования и переименования каталогов и файлов средствами ОС, то есть с минимальными накладными расходами для приложения: fs::copy, fs::copy_file и fs::rename.
• для обрезания или увеличения размера файла (путём забивания нулями): fs::resize_file.

Все подобные операции могут завершиться с ошибкой не по вине программиста, а из-за отказа операционной системы: например, процессу не хватит прав для удаления каталога. В одних приложениях такая ошибка доступа приводит к срыву всей операции и должна порождать исключение, в других — это типичная ситуация, которую приложение должно быстро обработать, и желательно без исключений. Чтобы учесть интересы всех программистов, каждая операция над файлами и каталогами в filesystem имеет две версии:

• более простая версия выбрасывает исключение типа std::system_error при ошибке
• более сложная версия принимает дополнительный out-параметр типа std::error_code, в который в случае ошибки записывается код ошибки

Рекурсивный и нерекурсивный обход каталогов

До появления filesystem перечисление содержимого каталога в C++ было настоящей проблемой, решаемой чаще всего средствами нестандартного для C/C++ заголовка <dirent.h> и ручной работы с циклами и списками.

В C++17 модуль filesystem предоставляет как рекурсивный, так и нерекурсивный итератор для доступа к содержимому каталога. С ним легко сочетаются любые алгоритмы из STL или Boost.Range. Ниже показан пример рекурсивного обхода каталога “data”:

Запрос метаинформации о файле

С помощью filesystem можно родными средствами ОС узнать метаинформацию о файле, например:

• определить размер файла, не читая его содержимое: fs::file_size
• прочитать или установить последнее время записи данных каким-либо процессом в заданный файл: fs::last_write_time
• прочитать или установить права доступа к файлу: fs::permissions

Обработка symlink и hardlink

В современных UNIX-системах и даже в Windows есть так называемые мягкие и жёсткие ссылки на файлы, расположенные в другом месте.

• Мягкие ссылки хранят в метаданных файловой системы оригинальный путь файла, из-за этого они могут становиться битыми, если оригинальный файл удалят
• Жёсткие ссылки позволяют одному файлу одновременно быть доступным по нескольким путям, при этом все пути равноправны, а файл не удаляется, пока число жёстких ссылок на него не упадёт до нуля. Есть ограничение: жёсткие ссылки на один и тот же файл должны находиться на одном и том же разделе диска.

Эти ссылки воспринимаются как настоящие файлы при работе с ними через обычные средства, такие как fopen или std::ifstream. Но иногда возникает нужда поработать именно со ссылкой, и ОС предоставляют такой API, а filesystem абстрагирует программиста от ОС. Ниже показан пример работы с мягкими ссылками:

Информация о свободном месте на диске

Глобальная функция fs::space возвращает объект типа fs::space_info, который описывает объём свободного места на носителе, на котором расположен указанный путь. Если передать несколько путей, находящихся на одном носителе, результат будет одинаковым.

Возвращаемый объект содержит три показателя, все в байтах:

• capacity — общий объём носителя
• free — объём свободного места
• available — объём места, доступного непривелигированным процессам; этот показатель меньше или равен free — например, в Linux система резервирует 5% места для пользователя root и размер available скорее всего будет меньше на 5% от capacity.

Так можно вывести информацию о свободном месте на диске, где находися текущий рабочий каталог:

Решена ли проблема 2038 года?

Тип данных time_t на большинстве платформ хранит число секунд с полуночи 1 января 1970 года (хотя по стандарту единица измерения времени в time_t не определена, почти все используют секунды). Если time_t остаётся 32-битным, то возникает проблема 2038 года: именно в этот год произойдёт переполнение time_t, и время в формате UNIX Timestamp уже нельзя будет представить в виде 32-битной переменной.

В Windows по умолчанию используется 64-битный time_t. В Linux, к сожалению, нет. Это означает, что вы никогда не должны использовать time_t в своём повседневном коде! Напишите для своего проекта простой класс для создания и хранения Timestamp или воспользуйтесь библиотечным, таким как класс Poco::Timestamp. Для взаимодействия со стандартной библиотекой используйте struct tm.

Проблема 2038 года не была решена в boost::filesystem — в нём дата модификации файла передавалась в виде time_t. К счастью, std::filesystem не имеет такого недостатка: для хранения времени используются типы данных из chrono. Посмотрите пример:

Чего нет в filesystem?

Хотя в filesystem есть большинство популярных операций, некоторые задачи могут потребовать использования внешних библиотек либо API операционной системы. Примеры задач, не решённых в filesystem:

• определить, что путь является путём к сетевому хранилищу, а не к локальному диску
• определить путь к каталогу, в котором находится исполняемый файл процесса либо библиотека .dll/.so, код которой сейчас выполняется
• прочитать всю метаинформацию о файле за один запрос к ОС, а не за несколько

Впрочем, для решения таких задач нетрудно один раз написать вспомогательный класс, интерфейс которого будет использовать классы из filesystem.

Что ещё почитать

При составлении статьи мной были прочитаны и переосмыслены несколько англоязычных статей:

Если вы захотите ещё больше погрузиться в нюансы filesystem, то я советую их прочитать.

fstream — Справочник по C ++

класс

<поток>

 typedef basic_fstream  fstream; 

Класс файлового потока ввода / вывода

Объекты этого класса поддерживают объект filebuf в качестве своего внутреннего буфера потока , который выполняет операции ввода / вывода с файлом, с которым они связаны (если есть).

Файловые потоки связываются с файлами либо при создании, либо путем вызова элемента open .

Это экземпляр basic_fstream со следующими параметрами шаблона:

Типы элементов

event

Тип для обозначения типа события (общедоступный тип члена )

event_callback

Тип функции обратного вызова события (общедоступный тип члена )

сбой

Базовый класс для исключений потока (открытый класс-член )

fmtflags

Тип для флагов формата потока (общедоступный тип элемента )

Init

Инициализировать стандартные объекты потока (открытый класс-член )

iostate

Тип для флагов состояния потока (общедоступный тип члена )

openmode

Тип для флагов режима открытия потока (общедоступный тип элемента )

seekdir

Тип флага направления поиска потока (общедоступный тип элемента )

sentry (istream)

Подготовить поток для ввода (открытый класс-член )

sentry (ostream)

Подготовить поток для вывода (открытый класс-член )

Функции публичных членов

(конструктор)

Создать объект и при необходимости открыть файл (общедоступная функция-член )

открыть

Открыть файл (общедоступная функция-член )

is_open

Проверить, открыт ли файл (общедоступная функция-член )

закрыть

Закрыть файл (общедоступная функция-член )

rdbuf

Получить связанный объект filebuf (общедоступная функция-член )

operator =

Перемещение присвоения (общедоступная функция-член )

своп

Внутренние элементы подкачки (общедоступная функция-член )

  #include 
  

 namespace std {
  шаблон <диаграмма классов, черты класса = характеры-символы <диаграмма>>
    class basic_filebuf;
  используя filebuf = basic_filebuf ;
  используя wfilebuf = basic_filebuf ;

  шаблон <диаграмма классов, черты класса = признаки_символа <диаграмма>>
    class basic_ifstream;
  используя ifstream = basic_ifstream ;
  используя wifstream = basic_ifstream ;

  шаблон <диаграмма классов, черты класса = признаки_символа <диаграмма>>
    class basic_ofstream;
  использование ofstream = basic_ofstream ;
  используя wofstream = basic_ofstream ;

  шаблон <диаграмма классов, черты класса = признаки_символа <диаграмма>>
    class basic_fstream;
  используя fstream = basic_fstream ;
  используя wfstream = basic_fstream ;
} 

 namespace std {
  шаблон <класс CharT, class Traits = char_traits >
  class basic_filebuf: public basic_streambuf  {
  общественность:
    используя char_type = CharT;
    using int_type = typename Traits :: int_type;
    using pos_type = typename Traits :: pos_type;
    using off_type = typename Traits :: off_type;
    using traits_type = Traits;

    // конструкторы / деструктор
    basic_filebuf ();
    basic_filebuf (const basic_filebuf &) = удалить;
    basic_filebuf (базовый_filebuf && rhs);
    виртуальный ~ basic_filebuf ();

    // присваиваем и меняем местами
    basic_filebuf & operator = (const basic_filebuf &) = удалить;
    basic_filebuf & operator = (basic_filebuf && rhs);
    недействительный своп (basic_filebuf & rhs);

    // члены
    bool is_open () const;
    basic_filebuf * open (const char * s, режим ios_base :: openmode);
    basic_filebuf * open (const filesystem :: path :: value_type * s,
                        ios_base :: openmode mode); // только широкие системы
    basic_filebuf * open (константная строка & s,
                        ios_base :: openmode mode);
    basic_filebuf * open (файловая система const :: путь & s,
                        ios_base :: openmode mode);
    basic_filebuf * close ();

  защищено:
    // переопределить виртуальные функции
    streamsize showmanyc () переопределить;
    int_type underflow () переопределение;
    int_type uflow () override;
    int_type pbackfail (int_type c = Traits :: eof ()) переопределить;
    int_type overflow (int_type c = Traits :: eof ()) override;

    basic_streambuf  * setbuf (char_type * s,
                                           размер потока n) переопределить;
    pos_type seekoff (off_type off, путь ios_base :: seekdir,
                     ios_base :: openmode который
                      = ios_base :: in | ios_base :: out) переопределить;
    pos_type seekpos (pos_type sp,
                     ios_base :: openmode который
                      = ios_base :: in | ios_base :: out) переопределить;
    int sync () переопределить;
    void imbue (const locale & loc) override;
  };

  шаблон <класс CharT, класс Traits>
    void swap (basic_filebuf  & x,
              basic_filebuf  & y);
} 

 namespace std {
  шаблон <класс CharT, class Traits = char_traits >
  class basic_ifstream: public basic_istream  {
  общественность:
    используя char_type = CharT;
    using int_type = typename Traits :: int_type;
    using pos_type = typename Traits :: pos_type;
    using off_type = typename Traits :: off_type;
    using traits_type = Traits;

    // конструкторы
    basic_ifstream ();
    явный basic_ifstream (const char * s,
                            ios_base :: openmode mode = ios_base :: in);
    явный basic_ifstream (const filesystem :: path :: value_type * s,
                            ios_base :: openmode mode = ios_base :: in); // только широкие системы
    явный basic_ifstream (const string & s,
                            ios_base :: openmode mode = ios_base :: in);
    явный basic_ifstream (const filesystem :: path & s,
                            ios_base :: openmode mode = ios_base :: in);
    basic_ifstream (const basic_ifstream &) = удалить;
    basic_ifstream (basic_ifstream && rhs);

    // присваиваем и меняем местами
    basic_ifstream & operator = (const basic_ifstream &) = удалить;
    basic_ifstream & operator = (basic_ifstream && rhs);
    недействительный своп (basic_ifstream & rhs);

    // члены
    basic_filebuf  * rdbuf () const;

    bool is_open () const;
    void open (const char * s, ios_base :: openmode mode = ios_base :: in);
    void open (const filesystem :: path :: value_type * s,
              ios_base :: openmode mode = ios_base :: in); // только широкие системы
    void open (const string & s, ios_base :: openmode mode = ios_base :: in);
    void open (const filesystem :: path & s, ios_base :: openmode mode = ios_base :: in);
    void close ();
  частный:
    basic_filebuf  sb; // только экспозиция
  };

  шаблон <класс CharT, класс Traits>
    void swap (basic_ifstream  & x,
              basic_ifstream  & y);
} 

 namespace std {
  шаблон <класс CharT, class Traits = char_traits >
  class basic_ofstream: public basic_ostream  {
  общественность:
    используя char_type = CharT;
    using int_type = typename Traits :: int_type;
    using pos_type = typename Traits :: pos_type;
    using off_type = typename Traits :: off_type;
    using traits_type = Traits;

    // конструкторы
    basic_ofstream ();
    явный basic_ofstream (const char * s,
                            ios_base :: openmode mode = ios_base :: out);
    явный basic_ofstream (const filesystem :: path :: value_type * s, // только для широких систем
                            ios_base :: openmode mode = ios_base :: out);
    явный basic_ofstream (const string & s,
                            ios_base :: openmode mode = ios_base :: out);
    явный basic_ofstream (const filesystem :: path & s,
                            ios_base :: openmode mode = ios_base :: out);
    basic_ofstream (const basic_ofstream &) = удалить;
    basic_ofstream (basic_ofstream && rhs);

    // присваиваем и меняем местами
    basic_ofstream & operator = (const basic_ofstream &) = удалить;
    basic_ofstream & operator = (basic_ofstream && rhs);
    недействительный своп (basic_ofstream & rhs);

    // члены
    basic_filebuf  * rdbuf () const;

    bool is_open () const;
    void open (const char * s, ios_base :: openmode mode = ios_base :: out);
    void open (const filesystem :: path :: value_type * s,
              ios_base :: openmode mode = ios_base :: out); // только широкие системы
    void open (const string & s, ios_base :: openmode mode = ios_base :: out);
    void open (const filesystem :: path & s, ios_base :: openmode mode = ios_base :: out);
    void close ();
  частный:
    basic_filebuf  sb; // только экспозиция
  };

  шаблон <класс CharT, класс Traits>
    void swap (basic_ofstream  & x,
              basic_ofstream <диаграмма, черты> & y);
} 

 namespace std {
  шаблон <класс CharT, class Traits = char_traits >
  class basic_fstream: public basic_iostream  {
  общественность:
    используя char_type = CharT;
    using int_type = typename Traits :: int_type;
    using pos_type = typename Traits :: pos_type;
    using off_type = typename Traits :: off_type;
    using traits_type = Traits;

    // конструкторы
    basic_fstream ();
    явный basic_fstream (
      const char * s,
      ios_base :: openmode mode = ios_base :: in | ios_base :: out);
    явный basic_fstream (
      const filesystem :: path :: value_type * s,
      ios_base :: openmode mode = ios_base :: in | ios_base :: out); // только широкие системы
    явный basic_fstream (
      константная строка & s,
      ios_base :: openmode mode = ios_base :: in | ios_base :: out);
    явный basic_fstream (
      const filesystem :: path & s,
      ios_base :: openmode mode = ios_base :: in | ios_base :: out);
    basic_fstream (const basic_fstream &) = удалить;
    basic_fstream (basic_fstream && rhs);

    // присваиваем и меняем местами
    basic_fstream & operator = (const basic_fstream &) = удалить;
    basic_fstream & operator = (basic_fstream && rhs);
    недействительный своп (basic_fstream & rhs);

    // члены
    basic_filebuf  * rdbuf () const;
    bool is_open () const;
    пусто открытый (
      const char * s,
      ios_base :: openmode mode = ios_base :: in | ios_base :: out);
    пусто открытый (
      const filesystem :: path :: value_type * s,
      ios_base :: openmode mode = ios_base :: in | ios_base :: out); // только широкие системы
    пусто открытый (
      константная строка & s,
      ios_base :: openmode mode = ios_base :: in | ios_base :: out);
    пусто открытый (
      const filesystem :: path & s,
      ios_base :: openmode mode = ios_base :: in | ios_base :: out);
    void close ();

  частный:
    basic_filebuf  sb; // только экспозиция
  };

  шаблон <класс CharT, класс Traits>
    void swap (basic_fstream  & x,
              basic_fstream  & y);
}