[file.streams] - C++14 → C++17

Files changed (1) hide show

tmp/tmpahkkqdv_/{from.md → to.md} +235 -498

tmp/tmpahkkqdv_/{from.md → to.md} RENAMED Viewed

@@ -1,93 +1,103 @@
 ## File-based streams <a id="file.streams">[[file.streams]]</a>
-### File streams <a id="fstreams">[[fstreams]]</a>
-The header `<fstream>` defines four class templates and eight types that
-associate stream buffers with files and assist reading and writing
-files.
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
     class basic_filebuf;
- typedef basic_filebuf<char>    filebuf;
- typedef basic_filebuf<wchar_t> wfilebuf;
   template <class charT, class traits = char_traits<charT>>
     class basic_ifstream;
- typedef basic_ifstream<char>    ifstream;
- typedef basic_ifstream<wchar_t> wifstream;
   template <class charT, class traits = char_traits<charT>>
     class basic_ofstream;
- typedef basic_ofstream<char>    ofstream;
- typedef basic_ofstream<wchar_t> wofstream;
   template <class charT, class traits = char_traits<charT>>
     class basic_fstream;
- typedef basic_fstream<char>     fstream;
- typedef basic_fstream<wchar_t> wfstream;
 }
 ```
-In this subclause, the type name `FILE` refers to the type `FILE`
-declared in `<cstdio>` ([[c.files]]).
-The class template `basic_filebuf` treats a file as a source or sink of
-bytes. In an environment that uses a large character set, the file
-typically holds multibyte character sequences and the `basic_filebuf`
-object converts those multibyte sequences into wide character sequences.
-#### Class template `basic_filebuf` <a id="filebuf">[[filebuf]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_filebuf : public basic_streambuf<charT, traits> {
   public:
- typedef charT                     char_type;
- typedef typename traits::int_type int_type;
- typedef typename traits::pos_type pos_type;
- typedef typename traits::off_type off_type;
- typedef traits                    traits_type;
-    // [filebuf.cons] Constructors/destructor:
     basic_filebuf();
     basic_filebuf(const basic_filebuf& rhs) = delete;
     basic_filebuf(basic_filebuf&& rhs);
     virtual ~basic_filebuf();
-    // [filebuf.assign] Assign/swap:
     basic_filebuf& operator=(const basic_filebuf& rhs) = delete;
     basic_filebuf& operator=(basic_filebuf&& rhs);
     void swap(basic_filebuf& rhs);
- // [filebuf.members] Members:
     bool is_open() const;
-    basic_filebuf<charT,traits>* open(const char* s,
                         ios_base::openmode mode);
-    basic_filebuf<charT,traits>* open(const string& s,
                         ios_base::openmode mode);
-    basic_filebuf<charT,traits>* close();
   protected:
-    // [filebuf.virtuals] Overridden virtual functions:
- virtual streamsize showmanyc();
- virtual int_type underflow();
- virtual int_type uflow();
- virtual int_type pbackfail(int_type c = traits::eof());
- virtual int_type overflow (int_type c = traits::eof());
- virtual basic_streambuf<charT,traits>*
-        setbuf(char_type* s, streamsize n);
- virtual pos_type seekoff(off_type off, ios_base::seekdir way,
- ios_base::openmode which = ios_base::in | ios_base::out);
-    virtual pos_type seekpos(pos_type sp,
-        ios_base::openmode which = ios_base::in | ios_base::out);
-    virtual int      sync();
-    virtual void     imbue(const locale& loc);
   };
   template <class charT, class traits>
     void swap(basic_filebuf<charT, traits>& x,
               basic_filebuf<charT, traits>& y);
@@ -97,23 +107,23 @@ namespace std {
 The class `basic_filebuf<charT, traits>` associates both the input
 sequence and the output sequence with a file.
 The restrictions on reading and writing a sequence controlled by an
 object of class `basic_filebuf<charT, traits>` are the same as for
-reading and writing with the Standard C library `FILE`s.
 In particular:
 - If the file is not open for reading the input sequence cannot be read.
 - If the file is not open for writing the output sequence cannot be
   written.
 - A joint file position is maintained for both the input sequence and
   the output sequence.
 An instance of `basic_filebuf` behaves as described in  [[filebuf]]
-provided `traits::pos_type` is `fpos<traits::state_type>`. Otherwise the
-behavior is undefined.
 In order to support file I/O and multibyte/wide character conversion,
 conversions are performed using members of a facet, referred to as
 `a_codecvt` in following sections, obtained as if by
@@ -130,11 +140,11 @@ basic_filebuf();
 *Effects:* Constructs an object of class `basic_filebuf<charT, traits>`,
 initializing the base class with
 `basic_streambuf<charT, traits>()` ([[streambuf.cons]]).
-`is_open() == false`.
 ``` cpp
 basic_filebuf(basic_filebuf&& rhs);
 ```
@@ -177,13 +187,13 @@ rethrown (see  [[res.on.exception.handling]]).
 ``` cpp
 basic_filebuf& operator=(basic_filebuf&& rhs);
 ```
-*Effects:* Calls `this->close()` then move assigns from `rhs`. After the
-move assignment `*this` has the observable state it would have had if it
-had been move constructed from `rhs` (see  [[filebuf.cons]]).
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_filebuf& rhs);
@@ -195,11 +205,11 @@ void swap(basic_filebuf& rhs);
 template <class charT, class traits>
   void swap(basic_filebuf<charT, traits>& x,
             basic_filebuf<charT, traits>& y);
 ```
-*Effects:* `x.swap(y)`.
 #### Member functions <a id="filebuf.members">[[filebuf.members]]</a>
 ``` cpp
 bool is_open() const;
@@ -207,18 +217,19 @@ bool is_open() const;
 *Returns:* `true` if a previous call to `open` succeeded (returned a
 non-null value) and there has been no intervening call to close.
 ``` cpp
-basic_filebuf<charT,traits>* open(const char* s,
-    ios_base::openmode mode);
 ```
 *Effects:* If `is_open() != false`, returns a null pointer. Otherwise,
 initializes the `filebuf` as required. It then opens a file, if
 possible, whose name is the NTBS`s` (as if by calling
-`std::fopen(s,modstr)`). The NTBS`modstr` is determined from
 `mode & ~ios_base::ate` as indicated in
 Table  [[tab:iostreams.file.open.modes]]. If `mode` is not some
 combination of flags shown in the table then the open fails.
 **Table: File open modes** <a id="tab:iostreams.file.open.modes">[tab:iostreams.file.open.modes]</a>
@@ -244,67 +255,67 @@ combination of flags shown in the table then the open fails.
 | +        | +    |       |         | +     | `"a+b"` |
 If the open operation succeeds and `(mode & ios_base::ate) != 0`,
 positions the file to the end (as if by calling
-`std::fseek(file,0,SEEK_END)`).[^39]
 If the repositioning operation fails, calls `close()` and returns a null
 pointer to indicate failure.
 *Returns:* `this` if successful, a null pointer otherwise.
 ``` cpp
-basic_filebuf<charT,traits>* open(const string& s,
- ios_base::openmode mode);
 ```
 *Returns:* `open(s.c_str(), mode);`
 ``` cpp
-basic_filebuf<charT,traits>* close();
 ```
 *Effects:* If `is_open() == false`, returns a null pointer. If a put
 area exists, calls `overflow(traits::eof())` to flush characters. If the
 last virtual member function called on `*this` (between `underflow`,
 `overflow`, `seekoff`, and `seekpos`) was `overflow` then calls
 `a_codecvt.unshift` (possibly several times) to determine a termination
 sequence, inserts those characters and calls `overflow(traits::eof())`
 again. Finally, regardless of whether any of the preceding calls fails
 or throws an exception, the function closes the file (as if by calling
-`std::fclose(file)`).[^40] If any of the calls made by the function,
-including `std::fclose`, fails, `close` fails by returning a null
-pointer. If one of these calls throws an exception, the exception is
-caught and rethrown after closing the file.
 *Returns:* `this` on success, a null pointer otherwise.
-`is_open() == false`.
 #### Overridden virtual functions <a id="filebuf.virtuals">[[filebuf.virtuals]]</a>
 ``` cpp
-streamsize showmanyc();
 ```
 *Effects:* Behaves the same as
 `basic_streambuf::showmanyc()` ([[streambuf.virtuals]]).
 *Remarks:* An implementation might well provide an overriding definition
 for this function signature if it can determine that more characters can
 be read from the input sequence.
 ``` cpp
-int_type underflow();
 ```
 *Effects:* Behaves according to the description of
 `basic_streambuf<charT, traits>::underflow()`, with the specialization
 that a sequence of characters is read from the input sequence as if by
 reading from the associated file into an internal buffer (`extern_buf`)
-and then as if by doing
 ``` cpp
 char   extern_buf[XSIZE];
 char*  extern_end;
 charT  intern_buf[ISIZE];
@@ -318,20 +329,20 @@ This shall be done in such a way that the class can recover the position
 (`fpos_t`) corresponding to each character between `intern_buf` and
 `intern_end`. If the value of `r` indicates that `a_codecvt.in()` ran
 out of space in `intern_buf`, retry with a larger `intern_buf`.
 ``` cpp
-int_type uflow();
 ```
 *Effects:* Behaves according to the description of
-`basic_streambuf<charT,traits>::uflow()`, with the specialization that a
-sequence of characters is read from the input with the same method as
 used by `underflow`.
 ``` cpp
-int_type pbackfail(int_type c = traits::eof());
 ```
 *Effects:* Puts back the character designated by `c` to the input
 sequence, if possible, in one of three ways:
@@ -359,11 +370,11 @@ sequence.
 If the function can succeed in more than one of these ways, it is
 unspecified which way is chosen. The function can alter the number of
 putback positions available as a result of any call.
 ``` cpp
-int_type overflow(int_type c = traits::eof());
 ```
 *Effects:* Behaves according to the description of
 `basic_streambuf<charT, traits>::overflow(c)`, except that the behavior
 of “consuming characters” is performed by first converting as if by:
@@ -392,31 +403,32 @@ and then
 *Returns:* `traits::not_eof(c)` to indicate success, and `traits::eof()`
 to indicate failure. If `is_open() == false`, the function always fails.
 ``` cpp
-basic_streambuf* setbuf(char_type* s, streamsize n);
 ```
 *Effects:* If `setbuf(0, 0)` is called on a stream before any I/O has
 occurred on that stream, the stream becomes unbuffered. Otherwise the
 results are *implementation-defined*. “Unbuffered” means that `pbase()`
 and `pptr()` always return null and output to the file should appear as
 soon as possible.
 ``` cpp
 pos_type seekoff(off_type off, ios_base::seekdir way,
- ios_base::openmode which = ios_base::in | ios_base::out);
 ```
 *Effects:* Let `width` denote `a_codecvt.encoding()`. If
 `is_open() == false`, or `off != 0 && width <= 0`, then the positioning
 operation fails. Otherwise, if `way != basic_ios::cur` or `off != 0`,
 and if the last operation was output, then update the output sequence
 and write any unshift sequence. Next, seek to the new position: if
-`width > 0`, call `std::fseek(file, width * off, whence)`, otherwise
-call `std::fseek(file, 0, whence)`.
 *Remarks:* “The last operation was output” means either the last virtual
 operation was overflow or the put buffer is non-empty. “Write any
 unshift sequence” means, if `width` if less than zero then call
 `a_codecvt.unshift(state, xbuf, xbuf+XSIZE, xbuf_end)` and output the
@@ -438,90 +450,99 @@ resultant stream position, if possible. If the positioning operation
 fails, or if the object cannot represent the resultant stream position,
 returns `pos_type(off_type(-1))`.
 ``` cpp
 pos_type seekpos(pos_type sp,
- ios_base::openmode which = ios_base::in | ios_base::out);
 ```
 Alters the file position, if possible, to correspond to the position
 stored in `sp` (as described below). Altering the file position performs
 as follows:
 1.  if `(om & ios_base::out) != 0`, then update the output sequence and
     write any unshift sequence;
-2.  set the file position to `sp`;
 3.  if `(om & ios_base::in) != 0`, then update the input sequence;
 where `om` is the open mode passed to the last call to `open()`. The
-operation fails if `is_open()` returns false.
 If `sp` is an invalid stream position, or if the function positions
 neither sequence, the positioning operation fails. If `sp` has not been
 obtained by a previous successful call to one of the positioning
 functions (`seekoff` or `seekpos`) on the same file the effects are
 undefined.
 *Returns:* `sp` on success. Otherwise returns `pos_type(off_type(-1))`.
 ``` cpp
-int sync();
 ```
 *Effects:* If a put area exists, calls `filebuf::overflow` to write the
-characters to the file. If a get area exists, the effect is
 *implementation-defined*.
 ``` cpp
-void imbue(const locale& loc);
 ```
-If the file is not positioned at its beginning and the encoding of the
-current locale as determined by `a_codecvt.encoding()` is
-state-dependent ([[locale.codecvt.virtuals]]) then that facet is the
 same as the corresponding facet of `loc`.
 *Effects:* Causes characters inserted or extracted after this call to be
 converted according to `loc` until another call of `imbue`.
-This may require reconversion of previously converted characters. This
-in turn may require the implementation to be able to reconstruct the
-original contents of the file.
-#### Class template `basic_ifstream` <a id="ifstream">[[ifstream]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_ifstream : public basic_istream<charT, traits> {
   public:
- typedef charT                     char_type;
- typedef typename traits::int_type int_type;
- typedef typename traits::pos_type pos_type;
- typedef typename traits::off_type off_type;
- typedef traits                    traits_type;
-    // [ifstream.cons] Constructors:
     basic_ifstream();
     explicit basic_ifstream(const char* s,
                             ios_base::openmode mode = ios_base::in);
     explicit basic_ifstream(const string& s,
                             ios_base::openmode mode = ios_base::in);
     basic_ifstream(const basic_ifstream& rhs) = delete;
     basic_ifstream(basic_ifstream&& rhs);
-    // [ifstream.assign] Assign/swap:
     basic_ifstream& operator=(const basic_ifstream& rhs) = delete;
     basic_ifstream& operator=(basic_ifstream&& rhs);
     void swap(basic_ifstream& rhs);
-    // [ifstream.members] Members:
     basic_filebuf<charT, traits>* rdbuf() const;
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::in);
     void open(const string& s, ios_base::openmode mode = ios_base::in);
     void close();
   private:
     basic_filebuf<charT, traits> sb; // exposition only
   };
@@ -542,18 +563,20 @@ presented here as:
 ``` cpp
 basic_ifstream();
 ```
-*Effects:* Constructs an object of class `basic_ifstream<charT,traits>`,
-initializing the base class with `basic_istream(&sb)` and initializing
-`sb` with `basic_filebuf<charT,traits>())` ([[istream.cons]],
-[[filebuf.cons]]).
 ``` cpp
 explicit basic_ifstream(const char* s,
                         ios_base::openmode mode = ios_base::in);
 ```
 *Effects:* Constructs an object of class `basic_ifstream`, initializing
 the base class with `basic_istream(&sb)` and initializing `sb` with
 `basic_filebuf<charT, traits>())` ([[istream.cons]], [[filebuf.cons]]),
@@ -561,13 +584,15 @@ then calls `rdbuf()->open(s, mode | ios_base::in)`. If that function
 returns a null pointer, calls `setstate(failbit)`.
 ``` cpp
 explicit basic_ifstream(const string& s,
                         ios_base::openmode mode = ios_base::in);
 ```
-*Effects:* the same as `basic_ifstream(s.c_str(), mode)`.
 ``` cpp
 basic_ifstream(basic_ifstream&& rhs);
 ```
@@ -598,11 +623,11 @@ void swap(basic_ifstream& rhs);
 template <class charT, class traits>
   void swap(basic_ifstream<charT, traits>& x,
             basic_ifstream<charT, traits>& y);
 ```
-*Effects:* `x.swap(y)`.
 #### Member functions <a id="ifstream.members">[[ifstream.members]]</a>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
@@ -616,64 +641,74 @@ bool is_open() const;
 *Returns:* `rdbuf()->is_open()`.
 ``` cpp
 void open(const char* s, ios_base::openmode mode = ios_base::in);
 ```
 *Effects:* Calls `rdbuf()->open(s, mode | ios_base::in)`. If that
 function does not return a null pointer calls `clear()`, otherwise calls
-`setstate(failbit)` (which may throw `ios_base::failure`
-([[iostate.flags]])).
 ``` cpp
 void open(const string& s, ios_base::openmode mode = ios_base::in);
 ```
-*Effects:* calls `open(s.c_str(), mode)`.
 ``` cpp
 void close();
 ```
 *Effects:* Calls `rdbuf()->close()` and, if that function returns a null
 pointer, calls `setstate(failbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]])).
-#### Class template `basic_ofstream` <a id="ofstream">[[ofstream]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_ofstream : public basic_ostream<charT, traits> {
   public:
- typedef charT                     char_type;
- typedef typename traits::int_type int_type;
- typedef typename traits::pos_type pos_type;
- typedef typename traits::off_type off_type;
- typedef traits                    traits_type;
-    // [ofstream.cons] Constructors:
     basic_ofstream();
     explicit basic_ofstream(const char* s,
                             ios_base::openmode mode = ios_base::out);
     explicit basic_ofstream(const string& s,
                             ios_base::openmode mode = ios_base::out);
     basic_ofstream(const basic_ofstream& rhs) = delete;
     basic_ofstream(basic_ofstream&& rhs);
-    // [ofstream.assign] Assign/swap:
     basic_ofstream& operator=(const basic_ofstream& rhs) = delete;
     basic_ofstream& operator=(basic_ofstream&& rhs);
     void swap(basic_ofstream& rhs);
-    // [ofstream.members] Members:
     basic_filebuf<charT, traits>* rdbuf() const;
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::out);
     void open(const string& s, ios_base::openmode mode = ios_base::out);
     void close();
   private:
     basic_filebuf<charT, traits> sb; // exposition only
   };
@@ -694,32 +729,37 @@ presented here as:
 ``` cpp
 basic_ofstream();
 ```
-*Effects:* Constructs an object of class `basic_ofstream<charT,traits>`,
-initializing the base class with `basic_ostream(&sb)` and initializing
-`sb` with `basic_filebuf<charT,traits>())` ([[ostream.cons]],
-[[filebuf.cons]]).
 ``` cpp
 explicit basic_ofstream(const char* s,
                         ios_base::openmode mode = ios_base::out);
 ```
-*Effects:* Constructs an object of class `basic_ofstream<charT,traits>`,
-initializing the base class with `basic_ostream(&sb)` and initializing
-`sb` with `basic_filebuf<charT,traits>())` ([[ostream.cons]],
-[[filebuf.cons]]), then calls `rdbuf()->open(s, mode|ios_base::out)`. If
-that function returns a null pointer, calls `setstate(failbit)`.
 ``` cpp
 explicit basic_ofstream(const string& s,
                         ios_base::openmode mode = ios_base::out);
 ```
-*Effects:* the same as `basic_ofstream(s.c_str(), mode);`
 ``` cpp
 basic_ofstream(basic_ofstream&& rhs);
 ```
@@ -750,11 +790,11 @@ void swap(basic_ofstream& rhs);
 template <class charT, class traits>
   void swap(basic_ofstream<charT, traits>& x,
             basic_ofstream<charT, traits>& y);
 ```
-*Effects:* `x.swap(y)`.
 #### Member functions <a id="ofstream.members">[[ofstream.members]]</a>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
@@ -768,66 +808,83 @@ bool is_open() const;
 *Returns:* `rdbuf()->is_open()`.
 ``` cpp
 void open(const char* s, ios_base::openmode mode = ios_base::out);
 ```
 *Effects:* Calls `rdbuf()->open(s, mode | ios_base::out)`. If that
 function does not return a null pointer calls `clear()`, otherwise calls
-`setstate(failbit)` (which may throw `ios_base::failure`
-([[iostate.flags]])).
 ``` cpp
 void close();
 ```
 *Effects:* Calls `rdbuf()->close()` and, if that function fails (returns
 a null pointer), calls `setstate(failbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]])).
 ``` cpp
 void open(const string& s, ios_base::openmode mode = ios_base::out);
 ```
-*Effects:* calls `open(s.c_str(), mode);`
-#### Class template `basic_fstream` <a id="fstream">[[fstream]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
-  class basic_fstream
-    : public basic_iostream<charT,traits> {
   public:
- typedef charT                     char_type;
- typedef typename traits::int_type int_type;
- typedef typename traits::pos_type pos_type;
- typedef typename traits::off_type off_type;
- typedef traits                    traits_type;
-    // constructors/destructor
     basic_fstream();
-    explicit basic_fstream(const char* s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
-    explicit basic_fstream(const string& s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
     basic_fstream(const basic_fstream& rhs) = delete;
     basic_fstream(basic_fstream&& rhs);
-    // [fstream.assign] Assign/swap:
     basic_fstream& operator=(const basic_fstream& rhs) = delete;
     basic_fstream& operator=(basic_fstream&& rhs);
     void swap(basic_fstream& rhs);
-    // Members:
     basic_filebuf<charT, traits>* rdbuf() const;
     bool is_open() const;
-    void open(const char* s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
-    void open(const string& s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
     void close();
   private:
     basic_filebuf<charT, traits> sb; // exposition only
@@ -838,13 +895,13 @@ namespace std {
               basic_fstream<charT, traits>& y);
 }
 ```
 The class template `basic_fstream<charT, traits>` supports reading and
-writing from named files. It uses a `basic_filebuf<charT,traits>` object
-to control the associated sequences. For the sake of exposition, the
-maintained data is presented here as:
 - `sb`, the `basic_filebuf` object.
 #### `basic_fstream` constructors <a id="fstream.cons">[[fstream.cons]]</a>
@@ -855,26 +912,34 @@ basic_fstream();
 *Effects:* Constructs an object of class `basic_fstream<charT, traits>`,
 initializing the base class with `basic_iostream(&sb)` and initializing
 `sb` with `basic_filebuf<charT, traits>()`.
 ``` cpp
-explicit basic_fstream(const char* s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
 ```
 *Effects:* Constructs an object of class `basic_fstream<charT, traits>`,
 initializing the base class with `basic_iostream(&sb)` and initializing
 `sb` with `basic_filebuf<charT, traits>()`. Then calls
 `rdbuf()->open(s, mode)`. If that function returns a null pointer, calls
 `setstate(failbit)`.
 ``` cpp
-explicit basic_fstream(const string& s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
 ```
-*Effects:* the same as `basic_fstream(s.c_str(), mode);`
 ``` cpp
 basic_fstream(basic_fstream&& rhs);
 ```
@@ -905,11 +970,11 @@ void swap(basic_fstream& rhs);
 template <class charT, class traits>
   void swap(basic_fstream<charT, traits>& x,
             basic_fstream<charT, traits>& y);
 ```
-*Effects:* `x.swap(y)`.
 #### Member functions <a id="fstream.members">[[fstream.members]]</a>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
@@ -922,365 +987,37 @@ bool is_open() const;
 ```
 *Returns:* `rdbuf()->is_open()`.
 ``` cpp
-void open(const char* s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
 ```
 *Effects:* Calls `rdbuf()->open(s, mode)`. If that function does not
 return a null pointer calls `clear()`, otherwise calls
-`setstate(failbit)`, (which may throw
 `ios_base::failure`) ([[iostate.flags]]).
 ``` cpp
-void open(const string& s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
 ```
-*Effects:* calls `open(s.c_str(), mode);`
 ``` cpp
 void close();
 ```
-*Effects:* Calls `rdbuf()->close()` and, if that function returns
-returns a null pointer, calls `setstate(failbit)` ([[iostate.flags]])
-(which may throw `ios_base::failure`).
-### C library files <a id="c.files">[[c.files]]</a>
-Table  [[tab:iostreams.hdr.cstdio]] describes header `<cstdio>`. C++does
-not define the function `gets`.
-Calls to the function `tmpnam` with an argument of `NULL` may introduce
-a data race ([[res.on.data.races]]) with other calls to `tmpnam` with
-an argument of `NULL`.
-ISO C 7.9, Amendment 1 4.6.2.
-Table  [[tab:iostreams.hdr.cinttypes]] describes header `<cinttypes>`.
-The macros defined by `<cinttypes>` are provided unconditionally. In
-particular, the symbol `__STDC_FORMAT_MACROS`, mentioned in footnote 182
-of the C standard, plays no role in C++.
-The contents of header `<cinttypes>` are the same as the Standard C
-Library header `<inttypes.h>`, with the following changes:
-- the header `<cinttypes>` includes the header `<cstdint>` instead of
-  `<stdint.h>`, and
-- if and only if the type `intmax_t` designates an extended integer
-  type ([[basic.fundamental]]), the following function signatures are
-  added:
-  ``` cpp
-  intmax_t abs(intmax_t);
-  imaxdiv_t div(intmax_t, intmax_t);
-  ```
-  which shall have the same semantics as the function signatures
-  `intmax_t imaxabs(intmax_t)` and
-  `imaxdiv_t imaxdiv(intmax_t, intmax_t)`, respectively.
-<!-- Link reference definitions -->
-[adjustfield.manip]: #adjustfield.manip
-[basefield.manip]: #basefield.manip
-[basic.fundamental]: basic.md#basic.fundamental
-[basic.ios.cons]: #basic.ios.cons
-[basic.ios.members]: #basic.ios.members
-[bitmask.types]: library.md#bitmask.types
-[c.files]: #c.files
-[enumerated.types]: library.md#enumerated.types
-[error.reporting]: #error.reporting
-[ext.manip]: #ext.manip
-[fig:streampos]: #fig:streampos
-[file.streams]: #file.streams
-[filebuf]: #filebuf
-[filebuf.assign]: #filebuf.assign
-[filebuf.cons]: #filebuf.cons
-[filebuf.members]: #filebuf.members
-[filebuf.virtuals]: #filebuf.virtuals
-[floatfield.manip]: #floatfield.manip
-[fmtflags.manip]: #fmtflags.manip
-[fmtflags.state]: #fmtflags.state
-[fpos]: #fpos
-[fpos.members]: #fpos.members
-[fpos.operations]: #fpos.operations
-[fstream]: #fstream
-[fstream.assign]: #fstream.assign
-[fstream.cons]: #fstream.cons
-[fstream.members]: #fstream.members
-[fstreams]: #fstreams
-[ifstream]: #ifstream
-[ifstream.assign]: #ifstream.assign
-[ifstream.cons]: #ifstream.cons
-[ifstream.members]: #ifstream.members
-[input.output]: #input.output
-[input.output.general]: #input.output.general
-[input.streams]: #input.streams
-[intro.multithread]: intro.md#intro.multithread
-[ios]: #ios
-[ios.base]: #ios.base
-[ios.base.callback]: #ios.base.callback
-[ios.base.cons]: #ios.base.cons
-[ios.base.locales]: #ios.base.locales
-[ios.base.storage]: #ios.base.storage
-[ios.members.static]: #ios.members.static
-[ios.overview]: #ios.overview
-[ios.types]: #ios.types
-[ios::Init]: #ios::Init
-[ios::failure]: #ios::failure
-[ios::fmtflags]: #ios::fmtflags
-[ios::iostate]: #ios::iostate
-[ios::openmode]: #ios::openmode
-[ios::seekdir]: #ios::seekdir
-[iostate.flags]: #iostate.flags
-[iostream.assign]: #iostream.assign
-[iostream.cons]: #iostream.cons
-[iostream.dest]: #iostream.dest
-[iostream.format]: #iostream.format
-[iostream.format.overview]: #iostream.format.overview
-[iostream.forward]: #iostream.forward
-[iostream.limits.imbue]: #iostream.limits.imbue
-[iostream.objects]: #iostream.objects
-[iostream.objects.overview]: #iostream.objects.overview
-[iostreamclass]: #iostreamclass
-[iostreams.base]: #iostreams.base
-[iostreams.base.overview]: #iostreams.base.overview
-[iostreams.limits.pos]: #iostreams.limits.pos
-[iostreams.requirements]: #iostreams.requirements
-[iostreams.threadsafety]: #iostreams.threadsafety
-[istream]: #istream
-[istream.assign]: #istream.assign
-[istream.cons]: #istream.cons
-[istream.formatted]: #istream.formatted
-[istream.formatted.arithmetic]: #istream.formatted.arithmetic
-[istream.formatted.reqmts]: #istream.formatted.reqmts
-[istream.manip]: #istream.manip
-[istream.rvalue]: #istream.rvalue
-[istream.unformatted]: #istream.unformatted
-[istream::extractors]: #istream::extractors
-[istream::sentry]: #istream::sentry
-[istringstream]: #istringstream
-[istringstream.assign]: #istringstream.assign
-[istringstream.cons]: #istringstream.cons
-[istringstream.members]: #istringstream.members
-[limits]: language.md#limits
-[locale.codecvt.virtuals]: localization.md#locale.codecvt.virtuals
-[locale.num.get]: localization.md#locale.num.get
-[narrow.stream.objects]: #narrow.stream.objects
-[ofstream]: #ofstream
-[ofstream.assign]: #ofstream.assign
-[ofstream.cons]: #ofstream.cons
-[ofstream.members]: #ofstream.members
-[ostream]: #ostream
-[ostream.assign]: #ostream.assign
-[ostream.cons]: #ostream.cons
-[ostream.formatted]: #ostream.formatted
-[ostream.formatted.reqmts]: #ostream.formatted.reqmts
-[ostream.inserters]: #ostream.inserters
-[ostream.inserters.arithmetic]: #ostream.inserters.arithmetic
-[ostream.inserters.character]: #ostream.inserters.character
-[ostream.manip]: #ostream.manip
-[ostream.rvalue]: #ostream.rvalue
-[ostream.seeks]: #ostream.seeks
-[ostream.unformatted]: #ostream.unformatted
-[ostream::sentry]: #ostream::sentry
-[ostringstream]: #ostringstream
-[ostringstream.assign]: #ostringstream.assign
-[ostringstream.cons]: #ostringstream.cons
-[ostringstream.members]: #ostringstream.members
-[output.streams]: #output.streams
-[quoted.manip]: #quoted.manip
-[res.on.data.races]: library.md#res.on.data.races
-[res.on.exception.handling]: library.md#res.on.exception.handling
-[std.ios.manip]: #std.ios.manip
-[std.manip]: #std.manip
-[stream.buffers]: #stream.buffers
-[stream.buffers.overview]: #stream.buffers.overview
-[stream.types]: #stream.types
-[streambuf]: #streambuf
-[streambuf.assign]: #streambuf.assign
-[streambuf.buffer]: #streambuf.buffer
-[streambuf.cons]: #streambuf.cons
-[streambuf.get.area]: #streambuf.get.area
-[streambuf.locales]: #streambuf.locales
-[streambuf.members]: #streambuf.members
-[streambuf.protected]: #streambuf.protected
-[streambuf.pub.get]: #streambuf.pub.get
-[streambuf.pub.pback]: #streambuf.pub.pback
-[streambuf.pub.put]: #streambuf.pub.put
-[streambuf.put.area]: #streambuf.put.area
-[streambuf.reqts]: #streambuf.reqts
-[streambuf.virt.buffer]: #streambuf.virt.buffer
-[streambuf.virt.get]: #streambuf.virt.get
-[streambuf.virt.locales]: #streambuf.virt.locales
-[streambuf.virt.pback]: #streambuf.virt.pback
-[streambuf.virt.put]: #streambuf.virt.put
-[streambuf.virtuals]: #streambuf.virtuals
-[string.classes]: strings.md#string.classes
-[string.streams]: #string.streams
-[string.streams.overview]: #string.streams.overview
-[stringbuf]: #stringbuf
-[stringbuf.assign]: #stringbuf.assign
-[stringbuf.cons]: #stringbuf.cons
-[stringbuf.members]: #stringbuf.members
-[stringbuf.virtuals]: #stringbuf.virtuals
-[strings]: strings.md#strings
-[stringstream]: #stringstream
-[stringstream.assign]: #stringstream.assign
-[stringstream.cons]: #stringstream.cons
-[stringstream.members]: #stringstream.members
-[tab:iostreams.basicios.init.effects]: #tab:iostreams.basicios.init.effects
-[tab:iostreams.copyfmt.effects]: #tab:iostreams.copyfmt.effects
-[tab:iostreams.file.open.modes]: #tab:iostreams.file.open.modes
-[tab:iostreams.fmtflags.constants]: #tab:iostreams.fmtflags.constants
-[tab:iostreams.fmtflags.effects]: #tab:iostreams.fmtflags.effects
-[tab:iostreams.hdr.cinttypes]: #tab:iostreams.hdr.cinttypes
-[tab:iostreams.hdr.cstdio]: #tab:iostreams.hdr.cstdio
-[tab:iostreams.iostate.effects]: #tab:iostreams.iostate.effects
-[tab:iostreams.lib.summary]: #tab:iostreams.lib.summary
-[tab:iostreams.newoff.values]: #tab:iostreams.newoff.values
-[tab:iostreams.openmode.effects]: #tab:iostreams.openmode.effects
-[tab:iostreams.position.requirements]: #tab:iostreams.position.requirements
-[tab:iostreams.seekdir.effects]: #tab:iostreams.seekdir.effects
-[tab:iostreams.seekoff.effects]: #tab:iostreams.seekoff.effects
-[tab:iostreams.seekoff.positioning]: #tab:iostreams.seekoff.positioning
-[wide.stream.objects]: #wide.stream.objects
-[^1]: It is the implementation’s responsibility to implement headers so
-    that including `<iosfwd>` and other headers does not violate the
-    rules about multiple occurrences of default arguments.
-[^2]: If it is possible for them to do so, implementations are
-    encouraged to initialize the objects earlier than required.
-[^3]: Constructors and destructors for static objects can access these
-    objects to read input from `stdin` or write output to `stdout` or
-    `stderr`.
-[^4]: Typically `long long`.
-[^5]: `streamsize` is used in most places where ISO C would use
-    `size_t`. Most of the uses of `streamsize` could use `size_t`,
-    except for the `strstreambuf` constructors, which require negative
-    values. It should probably be the signed type corresponding to
-    `size_t` (which is what Posix.2 calls `ssize_t`).
-[^6]: This implies that operations on a standard iostream object can be
-    mixed arbitrarily with operations on the corresponding stdio stream.
-    In practical terms, synchronization usually means that a standard
-    iostream object and a standard stdio object share a buffer.
-[^7]: An implementation is free to implement both the integer array
-    pointed at by `iarray` and the pointer array pointed at by `parray`
-    as sparse data structures, possibly with a one-element cache for
-    each.
-[^8]: for example, because it cannot allocate space.
-[^9]: for example, because it cannot allocate space.
-[^10]: This suggests an infinite amount of copying, but the
-    implementation can keep track of the maximum element of the arrays
-    that is non-zero.
-[^11]: Checking `badbit` also for `fail()` is historical practice.
-[^12]: The function signature `dec(ios_base&)` can be called by the
-    function signature
-    `basic_ostream& stream::operator<<(ios_base& (*)(ios_base&))` to
-    permit expressions of the form `cout <<dec` to change the format
-    flags stored in `cout`.
-[^13]: The default constructor is protected for class `basic_streambuf`
-    to assure that only objects for classes derived from this class may
-    be constructed.
-[^14]: `underflow` or `uflow` might fail by throwing an exception
-    prematurely. The intention is not only that the calls will not
-    return `eof()` but that they will return “immediately.”
-[^15]: Classes derived from `basic_streambuf` can provide more efficient
-    ways to implement `xsgetn()` and `xsputn()` by overriding these
-    definitions from the base class.
-[^16]: Typically, `overflow` returns `c` to indicate success, except
-    when `traits::eq_int_type(c,traits::eof())` returns `true`, in which
-    case it returns `traits::not_eof(c)`.
-[^17]: This will be possible only in functions that are part of the
-    library. The semantics of the constructor used in user code is as
-    specified.
-[^18]: The sentry constructor and destructor can also perform additional
-    implementation-dependent operations.
-[^19]: This is done without causing an `ios::failure` to be thrown.
-[^20]: See, for example, the function signature
-    `ws(basic_istream&)` ([[istream.manip]]).
-[^21]: See, for example, the function signature
-    `dec(ios_base&)` ([[basefield.manip]]).
-[^22]: This is done without causing an `ios::failure` to be thrown.
-[^23]: Note that this function is not overloaded on types `signed char`
-    and `unsigned char`.
-[^24]: Note that this function is not overloaded on types `signed char`
-    and `unsigned char`.
-[^25]: Note that this function is not overloaded on types `signed char`
-    and `unsigned char`.
-[^26]: Since the final input character is “extracted,” it is counted in
-    the `gcount()`, even though it is not stored.
-[^27]: This allows an input line which exactly fills the buffer, without
-    setting `failbit`. This is different behavior than the historical
-    AT&T implementation.
-[^28]: This implies an empty input line will not cause `failbit` to be
-    set.
-[^29]: Note that this function is not overloaded on types `signed char`
-    and `unsigned char`.
-[^30]: The call `os.tie()->flush()` does not necessarily occur if the
-    function can determine that no synchronization is necessary.
-[^31]: The `sentry` constructor and destructor can also perform
-    additional implementation-dependent operations.
-[^32]: without causing an `ios::failure` to be thrown.
-[^33]: See, for example, the function signature
-    `endl(basic_ostream&)` ([[ostream.manip]]).
-[^34]: See, for example, the function signature
-    `dec(ios_base&)` ([[basefield.manip]]).
-[^35]: without causing an `ios::failure` to be thrown.
-[^36]: Note that this function is not overloaded on types `signed char`
-    and `unsigned char`.
-[^37]: Note that this function is not overloaded on types `signed char`
-    and `unsigned char`.
-[^38]: The expression `cin >>resetiosflags(ios_base::skipws)` clears
-    `ios_base::skipws` in the format flags stored in the
-    `basic_istream<charT,traits>` object `cin` (the same as
-    `cin >>noskipws`), and the expression
-    `cout << resetiosflags(ios_base::showbase)` clears
-    `ios_base::showbase` in the format flags stored in the
-    `basic_ostream<charT,traits>` object `cout` (the same as
-    `cout <<noshowbase`).
-[^39]: The macro `SEEK_END` is defined, and the function signatures
-    `fopen(const char*, const char*)` and `fseek(FILE*, long, int)` are
-    declared, in `<cstdio>` ([[c.files]]).
-[^40]: The function signature `fclose(FILE*)` is declared in `<cstdio>`
-    ([[c.files]]).

 ## File-based streams <a id="file.streams">[[file.streams]]</a>
+### Header `<fstream>` synopsis <a id="fstream.syn">[[fstream.syn]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
     class basic_filebuf;
+ using filebuf  = basic_filebuf<char>;
+ using wfilebuf = basic_filebuf<wchar_t>;
   template <class charT, class traits = char_traits<charT>>
     class basic_ifstream;
+ using ifstream  = basic_ifstream<char>;
+ using wifstream = basic_ifstream<wchar_t>;
   template <class charT, class traits = char_traits<charT>>
     class basic_ofstream;
+ using ofstream  = basic_ofstream<char>;
+ using wofstream = basic_ofstream<wchar_t>;
   template <class charT, class traits = char_traits<charT>>
     class basic_fstream;
+ using fstream  = basic_fstream<char>;
+ using wfstream = basic_fstream<wchar_t>;
 }
 ```
+The header `<fstream>` defines four class templates and eight types that
+associate stream buffers with files and assist reading and writing
+files.
+[*Note 1*: The class template `basic_filebuf` treats a file as a source
+or sink of bytes. In an environment that uses a large character set, the
+file typically holds multibyte character sequences and the
+`basic_filebuf` object converts those multibyte sequences into wide
+character sequences. — *end note*]
+In this subclause, member functions taking arguments of
+`const filesystem::path::value_type*` are only be provided on systems
+where `filesystem::path::value_type` ([[fs.class.path]]) is not `char`.
+[*Note 2*: These functions enable class `path` support for systems with
+a wide native path character type, such as `wchar_t`. — *end note*]
+### Class template `basic_filebuf` <a id="filebuf">[[filebuf]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_filebuf : public basic_streambuf<charT, traits> {
   public:
+ using 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;
+    // [filebuf.cons], constructors/destructor
     basic_filebuf();
     basic_filebuf(const basic_filebuf& rhs) = delete;
     basic_filebuf(basic_filebuf&& rhs);
     virtual ~basic_filebuf();
+    // [filebuf.assign], assign and swap
     basic_filebuf& operator=(const basic_filebuf& rhs) = delete;
     basic_filebuf& operator=(basic_filebuf&& rhs);
     void swap(basic_filebuf& rhs);
+ // [filebuf.members], members
     bool is_open() const;
+    basic_filebuf* open(const char* s, ios_base::openmode mode);
+    basic_filebuf* open(const filesystem::path::value_type* s,
+                        ios_base::openmode mode);  // wide systems only; see [fstream.syn]
+    basic_filebuf* open(const string& s,
                         ios_base::openmode mode);
+    basic_filebuf* open(const filesystem::path& s,
                         ios_base::openmode mode);
+    basic_filebuf* close();
   protected:
+    // [filebuf.virtuals], overridden virtual functions
+    streamsize showmanyc() override;
+    int_type underflow() override;
+    int_type uflow() override;
+    int_type pbackfail(int_type c = traits::eof()) override;
+    int_type overflow (int_type c = traits::eof()) override;
+    basic_streambuf<charT, traits>* setbuf(char_type* s,
+ streamsize n) override;
+    pos_type seekoff(off_type off, ios_base::seekdir way,
+ ios_base::openmode which
+                      = ios_base::in | ios_base::out) override;
+    pos_type seekpos(pos_type sp,
+                     ios_base::openmode which
+                      = ios_base::in | ios_base::out) override;
+    int      sync() override;
+    void     imbue(const locale& loc) override;
   };
   template <class charT, class traits>
     void swap(basic_filebuf<charT, traits>& x,
               basic_filebuf<charT, traits>& y);
 The class `basic_filebuf<charT, traits>` associates both the input
 sequence and the output sequence with a file.
 The restrictions on reading and writing a sequence controlled by an
 object of class `basic_filebuf<charT, traits>` are the same as for
+reading and writing with the C standard library `FILE`s.
 In particular:
 - If the file is not open for reading the input sequence cannot be read.
 - If the file is not open for writing the output sequence cannot be
   written.
 - A joint file position is maintained for both the input sequence and
   the output sequence.
 An instance of `basic_filebuf` behaves as described in  [[filebuf]]
+provided `traits::pos_type` is `fpos<traits::{}state_type>`. Otherwise
+the behavior is undefined.
 In order to support file I/O and multibyte/wide character conversion,
 conversions are performed using members of a facet, referred to as
 `a_codecvt` in following sections, obtained as if by
 *Effects:* Constructs an object of class `basic_filebuf<charT, traits>`,
 initializing the base class with
 `basic_streambuf<charT, traits>()` ([[streambuf.cons]]).
+*Postconditions:* `is_open() == false`.
 ``` cpp
 basic_filebuf(basic_filebuf&& rhs);
 ```
 ``` cpp
 basic_filebuf& operator=(basic_filebuf&& rhs);
 ```
+*Effects:* Calls `close()` then move assigns from `rhs`. After the move
+assignment `*this` has the observable state it would have had if it had
+been move constructed from `rhs` (see  [[filebuf.cons]]).
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_filebuf& rhs);
 template <class charT, class traits>
   void swap(basic_filebuf<charT, traits>& x,
             basic_filebuf<charT, traits>& y);
 ```
+*Effects:* As if by `x.swap(y)`.
 #### Member functions <a id="filebuf.members">[[filebuf.members]]</a>
 ``` cpp
 bool is_open() const;
 *Returns:* `true` if a previous call to `open` succeeded (returned a
 non-null value) and there has been no intervening call to close.
 ``` cpp
+basic_filebuf* open(const char* s, ios_base::openmode mode);
+basic_filebuf* open(const filesystem::path::value_type* s,
+                    ios_base::openmode mode);  // wide systems only; see [fstream.syn]
 ```
 *Effects:* If `is_open() != false`, returns a null pointer. Otherwise,
 initializes the `filebuf` as required. It then opens a file, if
 possible, whose name is the NTBS`s` (as if by calling
+`fopen(s, modstr)`). The NTBS`modstr` is determined from
 `mode & ~ios_base::ate` as indicated in
 Table  [[tab:iostreams.file.open.modes]]. If `mode` is not some
 combination of flags shown in the table then the open fails.
 **Table: File open modes** <a id="tab:iostreams.file.open.modes">[tab:iostreams.file.open.modes]</a>
 | +        | +    |       |         | +     | `"a+b"` |
 If the open operation succeeds and `(mode & ios_base::ate) != 0`,
 positions the file to the end (as if by calling
+`fseek(file, 0, SEEK_END)`).[^40]
 If the repositioning operation fails, calls `close()` and returns a null
 pointer to indicate failure.
 *Returns:* `this` if successful, a null pointer otherwise.
 ``` cpp
+basic_filebuf* open(const string& s, ios_base::openmode mode);
+basic_filebuf* open(const filesystem::path& s, ios_base::openmode mode);
 ```
 *Returns:* `open(s.c_str(), mode);`
 ``` cpp
+basic_filebuf* close();
 ```
 *Effects:* If `is_open() == false`, returns a null pointer. If a put
 area exists, calls `overflow(traits::eof())` to flush characters. If the
 last virtual member function called on `*this` (between `underflow`,
 `overflow`, `seekoff`, and `seekpos`) was `overflow` then calls
 `a_codecvt.unshift` (possibly several times) to determine a termination
 sequence, inserts those characters and calls `overflow(traits::eof())`
 again. Finally, regardless of whether any of the preceding calls fails
 or throws an exception, the function closes the file (as if by calling
+`fclose(file)`). If any of the calls made by the function, including
+`fclose`, fails, `close` fails by returning a null pointer. If one of
+these calls throws an exception, the exception is caught and rethrown
+after closing the file.
 *Returns:* `this` on success, a null pointer otherwise.
+*Postconditions:* `is_open() == false`.
 #### Overridden virtual functions <a id="filebuf.virtuals">[[filebuf.virtuals]]</a>
 ``` cpp
+streamsize showmanyc() override;
 ```
 *Effects:* Behaves the same as
 `basic_streambuf::showmanyc()` ([[streambuf.virtuals]]).
 *Remarks:* An implementation might well provide an overriding definition
 for this function signature if it can determine that more characters can
 be read from the input sequence.
 ``` cpp
+int_type underflow() override;
 ```
 *Effects:* Behaves according to the description of
 `basic_streambuf<charT, traits>::underflow()`, with the specialization
 that a sequence of characters is read from the input sequence as if by
 reading from the associated file into an internal buffer (`extern_buf`)
+and then as if by doing:
 ``` cpp
 char   extern_buf[XSIZE];
 char*  extern_end;
 charT  intern_buf[ISIZE];
 (`fpos_t`) corresponding to each character between `intern_buf` and
 `intern_end`. If the value of `r` indicates that `a_codecvt.in()` ran
 out of space in `intern_buf`, retry with a larger `intern_buf`.
 ``` cpp
+int_type uflow() override;
 ```
 *Effects:* Behaves according to the description of
+`basic_streambuf<charT, traits>::uflow()`, with the specialization that
+a sequence of characters is read from the input with the same method as
 used by `underflow`.
 ``` cpp
+int_type pbackfail(int_type c = traits::eof()) override;
 ```
 *Effects:* Puts back the character designated by `c` to the input
 sequence, if possible, in one of three ways:
 If the function can succeed in more than one of these ways, it is
 unspecified which way is chosen. The function can alter the number of
 putback positions available as a result of any call.
 ``` cpp
+int_type overflow(int_type c = traits::eof()) override;
 ```
 *Effects:* Behaves according to the description of
 `basic_streambuf<charT, traits>::overflow(c)`, except that the behavior
 of “consuming characters” is performed by first converting as if by:
 *Returns:* `traits::not_eof(c)` to indicate success, and `traits::eof()`
 to indicate failure. If `is_open() == false`, the function always fails.
 ``` cpp
+basic_streambuf* setbuf(char_type* s, streamsize n) override;
 ```
 *Effects:* If `setbuf(0, 0)` is called on a stream before any I/O has
 occurred on that stream, the stream becomes unbuffered. Otherwise the
 results are *implementation-defined*. “Unbuffered” means that `pbase()`
 and `pptr()` always return null and output to the file should appear as
 soon as possible.
 ``` cpp
 pos_type seekoff(off_type off, ios_base::seekdir way,
+ ios_base::openmode which
+                   = ios_base::in | ios_base::out) override;
 ```
 *Effects:* Let `width` denote `a_codecvt.encoding()`. If
 `is_open() == false`, or `off != 0 && width <= 0`, then the positioning
 operation fails. Otherwise, if `way != basic_ios::cur` or `off != 0`,
 and if the last operation was output, then update the output sequence
 and write any unshift sequence. Next, seek to the new position: if
+`width > 0`, call `fseek(file, width * off, whence)`, otherwise call
+`fseek(file, 0, whence)`.
 *Remarks:* “The last operation was output” means either the last virtual
 operation was overflow or the put buffer is non-empty. “Write any
 unshift sequence” means, if `width` if less than zero then call
 `a_codecvt.unshift(state, xbuf, xbuf+XSIZE, xbuf_end)` and output the
 fails, or if the object cannot represent the resultant stream position,
 returns `pos_type(off_type(-1))`.
 ``` cpp
 pos_type seekpos(pos_type sp,
+ ios_base::openmode which
+                   = ios_base::in | ios_base::out) override;
 ```
 Alters the file position, if possible, to correspond to the position
 stored in `sp` (as described below). Altering the file position performs
 as follows:
 1.  if `(om & ios_base::out) != 0`, then update the output sequence and
     write any unshift sequence;
+2.  set the file position to `sp` as if by a call to `fsetpos`;
 3.  if `(om & ios_base::in) != 0`, then update the input sequence;
 where `om` is the open mode passed to the last call to `open()`. The
+operation fails if `is_open()` returns `false`.
 If `sp` is an invalid stream position, or if the function positions
 neither sequence, the positioning operation fails. If `sp` has not been
 obtained by a previous successful call to one of the positioning
 functions (`seekoff` or `seekpos`) on the same file the effects are
 undefined.
 *Returns:* `sp` on success. Otherwise returns `pos_type(off_type(-1))`.
 ``` cpp
+int sync() override;
 ```
 *Effects:* If a put area exists, calls `filebuf::overflow` to write the
+characters to the file, then flushes the file as if by calling
+`fflush(file)`. If a get area exists, the effect is
 *implementation-defined*.
 ``` cpp
+void imbue(const locale& loc) override;
 ```
+*Requires:* If the file is not positioned at its beginning and the
+encoding of the current locale as determined by `a_codecvt.encoding()`
+is state-dependent ([[locale.codecvt.virtuals]]) then that facet is the
 same as the corresponding facet of `loc`.
 *Effects:* Causes characters inserted or extracted after this call to be
 converted according to `loc` until another call of `imbue`.
+*Remarks:* This may require reconversion of previously converted
+characters. This in turn may require the implementation to be able to
+reconstruct the original contents of the file.
+### Class template `basic_ifstream` <a id="ifstream">[[ifstream]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_ifstream : public basic_istream<charT, traits> {
   public:
+ using 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;
+    // [ifstream.cons], constructors
     basic_ifstream();
     explicit basic_ifstream(const char* s,
                             ios_base::openmode mode = ios_base::in);
+    explicit basic_ifstream(const filesystem::path::value_type* s,
+                            ios_base::openmode mode = ios_base::in);  // wide systems only; see [fstream.syn]
     explicit basic_ifstream(const string& s,
                             ios_base::openmode mode = ios_base::in);
+    explicit basic_ifstream(const filesystem::path& s,
+                            ios_base::openmode mode = ios_base::in);
     basic_ifstream(const basic_ifstream& rhs) = delete;
     basic_ifstream(basic_ifstream&& rhs);
+    // [ifstream.assign], assign and swap
     basic_ifstream& operator=(const basic_ifstream& rhs) = delete;
     basic_ifstream& operator=(basic_ifstream&& rhs);
     void swap(basic_ifstream& rhs);
+    // [ifstream.members], members
     basic_filebuf<charT, traits>* 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);  // wide systems only; see [fstream.syn]
     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();
   private:
     basic_filebuf<charT, traits> sb; // exposition only
   };
 ``` cpp
 basic_ifstream();
 ```
+*Effects:* Constructs an object of class
+`basic_ifstream<charT, traits>`, initializing the base class with
+`basic_istream(&sb)` and initializing `sb` with
+`basic_filebuf<charT, traits>())` ([[istream.cons]], [[filebuf.cons]]).
 ``` cpp
 explicit basic_ifstream(const char* s,
                         ios_base::openmode mode = ios_base::in);
+explicit basic_ifstream(const filesystem::path::value_type* s,
+                        ios_base::openmode mode = ios_base::in);  // wide systems only; see [fstream.syn]
 ```
 *Effects:* Constructs an object of class `basic_ifstream`, initializing
 the base class with `basic_istream(&sb)` and initializing `sb` with
 `basic_filebuf<charT, traits>())` ([[istream.cons]], [[filebuf.cons]]),
 returns a null pointer, calls `setstate(failbit)`.
 ``` cpp
 explicit basic_ifstream(const string& s,
                         ios_base::openmode mode = ios_base::in);
+explicit basic_ifstream(const filesystem::path& s,
+                        ios_base::openmode mode = ios_base::in);
 ```
+*Effects:* The same as `basic_ifstream(s.c_str(), mode)`.
 ``` cpp
 basic_ifstream(basic_ifstream&& rhs);
 ```
 template <class charT, class traits>
   void swap(basic_ifstream<charT, traits>& x,
             basic_ifstream<charT, traits>& y);
 ```
+*Effects:* As if by `x.swap(y)`.
 #### Member functions <a id="ifstream.members">[[ifstream.members]]</a>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
 *Returns:* `rdbuf()->is_open()`.
 ``` cpp
 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);  // wide systems only; see [fstream.syn]
 ```
 *Effects:* Calls `rdbuf()->open(s, mode | ios_base::in)`. If that
 function does not return a null pointer calls `clear()`, otherwise calls
+`setstate(failbit)` (which may throw `ios_base::failure`)
+([[iostate.flags]]).
 ``` cpp
 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);
 ```
+*Effects:* Calls `open(s.c_str(), mode)`.
 ``` cpp
 void close();
 ```
 *Effects:* Calls `rdbuf()->close()` and, if that function returns a null
 pointer, calls `setstate(failbit)` (which may throw
+`ios_base::failure`) ([[iostate.flags]]).
+### Class template `basic_ofstream` <a id="ofstream">[[ofstream]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_ofstream : public basic_ostream<charT, traits> {
   public:
+ using 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;
+    // [ofstream.cons], constructors
     basic_ofstream();
     explicit basic_ofstream(const char* s,
                             ios_base::openmode mode = ios_base::out);
+    explicit basic_ofstream(const filesystem::path::value_type* s,
+                            ios_base::openmode mode = ios_base::out);  // wide systems only; see [fstream.syn]
     explicit basic_ofstream(const string& s,
                             ios_base::openmode mode = ios_base::out);
+    explicit basic_ofstream(const filesystem::path& s,
+                            ios_base::openmode mode = ios_base::out);
     basic_ofstream(const basic_ofstream& rhs) = delete;
     basic_ofstream(basic_ofstream&& rhs);
+    // [ofstream.assign], assign and swap
     basic_ofstream& operator=(const basic_ofstream& rhs) = delete;
     basic_ofstream& operator=(basic_ofstream&& rhs);
     void swap(basic_ofstream& rhs);
+    // [ofstream.members], members
     basic_filebuf<charT, traits>* 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);  // wide systems only; see [fstream.syn]
     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();
   private:
     basic_filebuf<charT, traits> sb; // exposition only
   };
 ``` cpp
 basic_ofstream();
 ```
+*Effects:* Constructs an object of class
+`basic_ofstream<charT, traits>`, initializing the base class with
+`basic_ostream(&sb)` and initializing `sb` with
+`basic_filebuf<charT, traits>())` ([[ostream.cons]], [[filebuf.cons]]).
 ``` cpp
 explicit basic_ofstream(const char* s,
                         ios_base::openmode mode = ios_base::out);
+explicit basic_ofstream(const filesystem::path::value_type* s,
+                        ios_base::openmode mode = ios_base::out); // wide systems only; see [fstream.syn]
 ```
+*Effects:* Constructs an object of class
+`basic_ofstream<charT, traits>`, initializing the base class with
+`basic_ostream(&sb)` and initializing `sb` with
+`basic_filebuf<charT, traits>())` ([[ostream.cons]], [[filebuf.cons]]),
+then calls `rdbuf()->open(s, mode | ios_base::out)`. If that function
+returns a null pointer, calls `setstate(failbit)`.
 ``` cpp
 explicit basic_ofstream(const string& s,
                         ios_base::openmode mode = ios_base::out);
+explicit basic_ofstream(const filesystem::path& s,
+                        ios_base::openmode mode = ios_base::out);
 ```
+*Effects:* The same as `basic_ofstream(s.c_str(), mode)`.
 ``` cpp
 basic_ofstream(basic_ofstream&& rhs);
 ```
 template <class charT, class traits>
   void swap(basic_ofstream<charT, traits>& x,
             basic_ofstream<charT, traits>& y);
 ```
+*Effects:* As if by `x.swap(y)`.
 #### Member functions <a id="ofstream.members">[[ofstream.members]]</a>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
 *Returns:* `rdbuf()->is_open()`.
 ``` cpp
 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);  // wide systems only; see [fstream.syn]
 ```
 *Effects:* Calls `rdbuf()->open(s, mode | ios_base::out)`. If that
 function does not return a null pointer calls `clear()`, otherwise calls
+`setstate(failbit)` (which may throw `ios_base::failure`)
+([[iostate.flags]]).
 ``` cpp
 void close();
 ```
 *Effects:* Calls `rdbuf()->close()` and, if that function fails (returns
 a null pointer), calls `setstate(failbit)` (which may throw
+`ios_base::failure`) ([[iostate.flags]]).
 ``` cpp
 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);
 ```
+*Effects:* Calls `open(s.c_str(), mode)`.
+### Class template `basic_fstream` <a id="fstream">[[fstream]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
+  class basic_fstream : public basic_iostream<charT, traits> {
   public:
+ using 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;
+    // [fstream.cons], constructors
     basic_fstream();
+    explicit basic_fstream(
+      const char* s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
+    explicit basic_fstream(
+      const std::filesystem::path::value_type* s,
+      ios_base::openmode mode = ios_base::in|ios_base::out);  // wide systems only; see [fstream.syn]
+    explicit basic_fstream(
+      const string& s,
+      ios_base::openmode mode = ios_base::in | ios_base::out);
+    explicit basic_fstream(
+      const filesystem::path& s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
     basic_fstream(const basic_fstream& rhs) = delete;
     basic_fstream(basic_fstream&& rhs);
+    // [fstream.assign], assign and swap
     basic_fstream& operator=(const basic_fstream& rhs) = delete;
     basic_fstream& operator=(basic_fstream&& rhs);
     void swap(basic_fstream& rhs);
+    // [fstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
     bool is_open() const;
+    void open(
+      const char* s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
+    void open(
+      const std::filesystem::path::value_type* s,
+      ios_base::openmode mode = ios_base::in|ios_base::out);  // wide systems only; see [fstream.syn]
+    void open(
+      const string& s,
+      ios_base::openmode mode = ios_base::in | ios_base::out);
+    void open(
+      const filesystem::path& s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
     void close();
   private:
     basic_filebuf<charT, traits> sb; // exposition only
               basic_fstream<charT, traits>& y);
 }
 ```
 The class template `basic_fstream<charT, traits>` supports reading and
+writing from named files. It uses a `basic_filebuf<charT, traits>`
+object to control the associated sequences. For the sake of exposition,
+the maintained data is presented here as:
 - `sb`, the `basic_filebuf` object.
 #### `basic_fstream` constructors <a id="fstream.cons">[[fstream.cons]]</a>
 *Effects:* Constructs an object of class `basic_fstream<charT, traits>`,
 initializing the base class with `basic_iostream(&sb)` and initializing
 `sb` with `basic_filebuf<charT, traits>()`.
 ``` cpp
+explicit basic_fstream(
+  const char* s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
+explicit basic_fstream(
+  const filesystem::path::value_type* s,
+  ios_base::openmode mode = ios_base::in | ios_base::out);  // wide systems only; see [fstream.syn]
 ```
 *Effects:* Constructs an object of class `basic_fstream<charT, traits>`,
 initializing the base class with `basic_iostream(&sb)` and initializing
 `sb` with `basic_filebuf<charT, traits>()`. Then calls
 `rdbuf()->open(s, mode)`. If that function returns a null pointer, calls
 `setstate(failbit)`.
 ``` cpp
+explicit basic_fstream(
+  const string& s,
+  ios_base::openmode mode = ios_base::in | ios_base::out);
+explicit basic_fstream(
+  const filesystem::path& s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
 ```
+*Effects:* The same as `basic_fstream(s.c_str(), mode)`.
 ``` cpp
 basic_fstream(basic_fstream&& rhs);
 ```
 template <class charT, class traits>
   void swap(basic_fstream<charT, traits>& x,
             basic_fstream<charT, traits>& y);
 ```
+*Effects:* As if by `x.swap(y)`.
 #### Member functions <a id="fstream.members">[[fstream.members]]</a>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
 ```
 *Returns:* `rdbuf()->is_open()`.
 ``` cpp
+void open(
+  const char* s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
+void open(
+  const filesystem::path::value_type* s,
+  ios_base::openmode mode = ios_base::in | ios_base::out);  // wide systems only; see [fstream.syn]
 ```
 *Effects:* Calls `rdbuf()->open(s, mode)`. If that function does not
 return a null pointer calls `clear()`, otherwise calls
+`setstate(failbit)` (which may throw
 `ios_base::failure`) ([[iostate.flags]]).
 ``` cpp
+void open(
+  const string& s,
+  ios_base::openmode mode = ios_base::in | ios_base::out);
+void open(
+  const filesystem::path& s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
 ```
+*Effects:* Calls `open(s.c_str(), mode)`.
 ``` cpp
 void close();
 ```
+*Effects:* Calls `rdbuf()->close()` and, if that function returns a null
+pointer, calls `setstate(failbit)` (which may throw
+`ios_base::failure`) ([[iostate.flags]]).

Diff to HTML by rtfpessoa