libstdc++
fstream
Go to the documentation of this file.
1 // File based streams -*- C++ -*-
2 
3 // Copyright (C) 1997-2017 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file include/fstream
26  * This is a Standard C++ Library header.
27  */
28 
29 //
30 // ISO C++ 14882: 27.8 File-based streams
31 //
32 
33 #ifndef _GLIBCXX_FSTREAM
34 #define _GLIBCXX_FSTREAM 1
35 
36 #pragma GCC system_header
37 
38 #include <istream>
39 #include <ostream>
40 #include <bits/codecvt.h>
41 #include <cstdio> // For BUFSIZ
42 #include <bits/basic_file.h> // For __basic_file, __c_lock
43 #if __cplusplus >= 201103L
44 #include <string> // For std::string overloads.
45 #endif
46 
47 namespace std _GLIBCXX_VISIBILITY(default)
48 {
49 _GLIBCXX_BEGIN_NAMESPACE_VERSION
50 
51  // [27.8.1.1] template class basic_filebuf
52  /**
53  * @brief The actual work of input and output (for files).
54  * @ingroup io
55  *
56  * @tparam _CharT Type of character stream.
57  * @tparam _Traits Traits for character type, defaults to
58  * char_traits<_CharT>.
59  *
60  * This class associates both its input and output sequence with an
61  * external disk file, and maintains a joint file position for both
62  * sequences. Many of its semantics are described in terms of similar
63  * behavior in the Standard C Library's @c FILE streams.
64  *
65  * Requirements on traits_type, specific to this class:
66  * - traits_type::pos_type must be fpos<traits_type::state_type>
67  * - traits_type::off_type must be streamoff
68  * - traits_type::state_type must be Assignable and DefaultConstructible,
69  * - traits_type::state_type() must be the initial state for codecvt.
70  */
71  template<typename _CharT, typename _Traits>
72  class basic_filebuf : public basic_streambuf<_CharT, _Traits>
73  {
74 #if __cplusplus >= 201103L
75  template<typename _Tp>
76  using __chk_state = __and_<is_copy_assignable<_Tp>,
77  is_copy_constructible<_Tp>,
78  is_default_constructible<_Tp>>;
79 
80  static_assert(__chk_state<typename _Traits::state_type>::value,
81  "state_type must be CopyAssignable, CopyConstructible"
82  " and DefaultConstructible");
83 
84  static_assert(is_same<typename _Traits::pos_type,
86  "pos_type must be fpos<state_type>");
87 #endif
88  public:
89  // Types:
90  typedef _CharT char_type;
91  typedef _Traits traits_type;
92  typedef typename traits_type::int_type int_type;
93  typedef typename traits_type::pos_type pos_type;
94  typedef typename traits_type::off_type off_type;
95 
98  typedef __basic_file<char> __file_type;
99  typedef typename traits_type::state_type __state_type;
101 
102  friend class ios_base; // For sync_with_stdio.
103 
104  protected:
105  // Data Members:
106  // MT lock inherited from libio or other low-level io library.
107  __c_lock _M_lock;
108 
109  // External buffer.
110  __file_type _M_file;
111 
112  /// Place to stash in || out || in | out settings for current filebuf.
113  ios_base::openmode _M_mode;
114 
115  // Beginning state type for codecvt.
116  __state_type _M_state_beg;
117 
118  // During output, the state that corresponds to pptr(),
119  // during input, the state that corresponds to egptr() and
120  // _M_ext_next.
121  __state_type _M_state_cur;
122 
123  // Not used for output. During input, the state that corresponds
124  // to eback() and _M_ext_buf.
125  __state_type _M_state_last;
126 
127  /// Pointer to the beginning of internal buffer.
128  char_type* _M_buf;
129 
130  /**
131  * Actual size of internal buffer. This number is equal to the size
132  * of the put area + 1 position, reserved for the overflow char of
133  * a full area.
134  */
135  size_t _M_buf_size;
136 
137  // Set iff _M_buf is allocated memory from _M_allocate_internal_buffer.
138  bool _M_buf_allocated;
139 
140  /**
141  * _M_reading == false && _M_writing == false for @b uncommitted mode;
142  * _M_reading == true for @b read mode;
143  * _M_writing == true for @b write mode;
144  *
145  * NB: _M_reading == true && _M_writing == true is unused.
146  */
148  bool _M_writing;
149 
150  //@{
151  /**
152  * Necessary bits for putback buffer management.
153  *
154  * @note pbacks of over one character are not currently supported.
155  */
156  char_type _M_pback;
157  char_type* _M_pback_cur_save;
158  char_type* _M_pback_end_save;
160  //@}
161 
162  // Cached codecvt facet.
163  const __codecvt_type* _M_codecvt;
164 
165  /**
166  * Buffer for external characters. Used for input when
167  * codecvt::always_noconv() == false. When valid, this corresponds
168  * to eback().
169  */
170  char* _M_ext_buf;
171 
172  /**
173  * Size of buffer held by _M_ext_buf.
174  */
176 
177  /**
178  * Pointers into the buffer held by _M_ext_buf that delimit a
179  * subsequence of bytes that have been read but not yet converted.
180  * When valid, _M_ext_next corresponds to egptr().
181  */
182  const char* _M_ext_next;
183  char* _M_ext_end;
184 
185  /**
186  * Initializes pback buffers, and moves normal buffers to safety.
187  * Assumptions:
188  * _M_in_cur has already been moved back
189  */
190  void
192  {
193  if (!_M_pback_init)
194  {
195  _M_pback_cur_save = this->gptr();
196  _M_pback_end_save = this->egptr();
197  this->setg(&_M_pback, &_M_pback, &_M_pback + 1);
198  _M_pback_init = true;
199  }
200  }
201 
202  /**
203  * Deactivates pback buffer contents, and restores normal buffer.
204  * Assumptions:
205  * The pback buffer has only moved forward.
206  */
207  void
209  {
210  if (_M_pback_init)
211  {
212  // Length _M_in_cur moved in the pback buffer.
213  _M_pback_cur_save += this->gptr() != this->eback();
214  this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save);
215  _M_pback_init = false;
216  }
217  }
218 
219  public:
220  // Constructors/destructor:
221  /**
222  * @brief Does not open any files.
223  *
224  * The default constructor initializes the parent class using its
225  * own default ctor.
226  */
227  basic_filebuf();
228 
229 #if __cplusplus >= 201103L
230  basic_filebuf(const basic_filebuf&) = delete;
232 #endif
233 
234  /**
235  * @brief The destructor closes the file first.
236  */
237  virtual
239  { this->close(); }
240 
241 #if __cplusplus >= 201103L
242  basic_filebuf& operator=(const basic_filebuf&) = delete;
243  basic_filebuf& operator=(basic_filebuf&&);
244  void swap(basic_filebuf&);
245 #endif
246 
247  // Members:
248  /**
249  * @brief Returns true if the external file is open.
250  */
251  bool
252  is_open() const throw()
253  { return _M_file.is_open(); }
254 
255  /**
256  * @brief Opens an external file.
257  * @param __s The name of the file.
258  * @param __mode The open mode flags.
259  * @return @c this on success, NULL on failure
260  *
261  * If a file is already open, this function immediately fails.
262  * Otherwise it tries to open the file named @a __s using the flags
263  * given in @a __mode.
264  *
265  * Table 92, adapted here, gives the relation between openmode
266  * combinations and the equivalent @c fopen() flags.
267  * (NB: lines app, in|out|app, in|app, binary|app, binary|in|out|app,
268  * and binary|in|app per DR 596)
269  * <pre>
270  * +---------------------------------------------------------+
271  * | ios_base Flag combination stdio equivalent |
272  * |binary in out trunc app |
273  * +---------------------------------------------------------+
274  * | + w |
275  * | + + a |
276  * | + a |
277  * | + + w |
278  * | + r |
279  * | + + r+ |
280  * | + + + w+ |
281  * | + + + a+ |
282  * | + + a+ |
283  * +---------------------------------------------------------+
284  * | + + wb |
285  * | + + + ab |
286  * | + + ab |
287  * | + + + wb |
288  * | + + rb |
289  * | + + + r+b |
290  * | + + + + w+b |
291  * | + + + + a+b |
292  * | + + + a+b |
293  * +---------------------------------------------------------+
294  * </pre>
295  */
296  __filebuf_type*
297  open(const char* __s, ios_base::openmode __mode);
298 
299 #if __cplusplus >= 201103L
300  /**
301  * @brief Opens an external file.
302  * @param __s The name of the file.
303  * @param __mode The open mode flags.
304  * @return @c this on success, NULL on failure
305  */
306  __filebuf_type*
307  open(const std::string& __s, ios_base::openmode __mode)
308  { return open(__s.c_str(), __mode); }
309 #endif
310 
311  /**
312  * @brief Closes the currently associated file.
313  * @return @c this on success, NULL on failure
314  *
315  * If no file is currently open, this function immediately fails.
316  *
317  * If a <em>put buffer area</em> exists, @c overflow(eof) is
318  * called to flush all the characters. The file is then
319  * closed.
320  *
321  * If any operations fail, this function also fails.
322  */
323  __filebuf_type*
324  close();
325 
326  protected:
327  void
328  _M_allocate_internal_buffer();
329 
330  void
331  _M_destroy_internal_buffer() throw();
332 
333  // [27.8.1.4] overridden virtual functions
334  virtual streamsize
335  showmanyc();
336 
337  // Stroustrup, 1998, p. 628
338  // underflow() and uflow() functions are called to get the next
339  // character from the real input source when the buffer is empty.
340  // Buffered input uses underflow()
341 
342  virtual int_type
343  underflow();
344 
345  virtual int_type
346  pbackfail(int_type __c = _Traits::eof());
347 
348  // Stroustrup, 1998, p 648
349  // The overflow() function is called to transfer characters to the
350  // real output destination when the buffer is full. A call to
351  // overflow(c) outputs the contents of the buffer plus the
352  // character c.
353  // 27.5.2.4.5
354  // Consume some sequence of the characters in the pending sequence.
355  virtual int_type
356  overflow(int_type __c = _Traits::eof());
357 
358  // Convert internal byte sequence to external, char-based
359  // sequence via codecvt.
360  bool
361  _M_convert_to_external(char_type*, streamsize);
362 
363  /**
364  * @brief Manipulates the buffer.
365  * @param __s Pointer to a buffer area.
366  * @param __n Size of @a __s.
367  * @return @c this
368  *
369  * If no file has been opened, and both @a __s and @a __n are zero, then
370  * the stream becomes unbuffered. Otherwise, @c __s is used as a
371  * buffer; see
372  * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering
373  * for more.
374  */
375  virtual __streambuf_type*
376  setbuf(char_type* __s, streamsize __n);
377 
378  virtual pos_type
379  seekoff(off_type __off, ios_base::seekdir __way,
380  ios_base::openmode __mode = ios_base::in | ios_base::out);
381 
382  virtual pos_type
383  seekpos(pos_type __pos,
384  ios_base::openmode __mode = ios_base::in | ios_base::out);
385 
386  // Common code for seekoff, seekpos, and overflow
387  pos_type
388  _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);
389 
390  int
391  _M_get_ext_pos(__state_type &__state);
392 
393  virtual int
394  sync();
395 
396  virtual void
397  imbue(const locale& __loc);
398 
399  virtual streamsize
400  xsgetn(char_type* __s, streamsize __n);
401 
402  virtual streamsize
403  xsputn(const char_type* __s, streamsize __n);
404 
405  // Flushes output buffer, then writes unshift sequence.
406  bool
407  _M_terminate_output();
408 
409  /**
410  * This function sets the pointers of the internal buffer, both get
411  * and put areas. Typically:
412  *
413  * __off == egptr() - eback() upon underflow/uflow (@b read mode);
414  * __off == 0 upon overflow (@b write mode);
415  * __off == -1 upon open, setbuf, seekoff/pos (@b uncommitted mode).
416  *
417  * NB: epptr() - pbase() == _M_buf_size - 1, since _M_buf_size
418  * reflects the actual allocated memory and the last cell is reserved
419  * for the overflow char of a full put area.
420  */
421  void
423  {
424  const bool __testin = _M_mode & ios_base::in;
425  const bool __testout = (_M_mode & ios_base::out
426  || _M_mode & ios_base::app);
427 
428  if (__testin && __off > 0)
429  this->setg(_M_buf, _M_buf, _M_buf + __off);
430  else
431  this->setg(_M_buf, _M_buf, _M_buf);
432 
433  if (__testout && __off == 0 && _M_buf_size > 1 )
434  this->setp(_M_buf, _M_buf + _M_buf_size - 1);
435  else
436  this->setp(0, 0);
437  }
438  };
439 
440  // [27.8.1.5] Template class basic_ifstream
441  /**
442  * @brief Controlling input for files.
443  * @ingroup io
444  *
445  * @tparam _CharT Type of character stream.
446  * @tparam _Traits Traits for character type, defaults to
447  * char_traits<_CharT>.
448  *
449  * This class supports reading from named files, using the inherited
450  * functions from std::basic_istream. To control the associated
451  * sequence, an instance of std::basic_filebuf is used, which this page
452  * refers to as @c sb.
453  */
454  template<typename _CharT, typename _Traits>
455  class basic_ifstream : public basic_istream<_CharT, _Traits>
456  {
457  public:
458  // Types:
459  typedef _CharT char_type;
460  typedef _Traits traits_type;
461  typedef typename traits_type::int_type int_type;
462  typedef typename traits_type::pos_type pos_type;
463  typedef typename traits_type::off_type off_type;
464 
465  // Non-standard types:
468 
469  private:
470  __filebuf_type _M_filebuf;
471 
472  public:
473  // Constructors/Destructors:
474  /**
475  * @brief Default constructor.
476  *
477  * Initializes @c sb using its default constructor, and passes
478  * @c &sb to the base class initializer. Does not open any files
479  * (you haven't given it a filename to open).
480  */
481  basic_ifstream() : __istream_type(), _M_filebuf()
482  { this->init(&_M_filebuf); }
483 
484  /**
485  * @brief Create an input file stream.
486  * @param __s Null terminated string specifying the filename.
487  * @param __mode Open file in specified mode (see std::ios_base).
488  *
489  * @c ios_base::in is automatically included in @a __mode.
490  *
491  * Tip: When using std::string to hold the filename, you must use
492  * .c_str() before passing it to this constructor.
493  */
494  explicit
495  basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
496  : __istream_type(), _M_filebuf()
497  {
498  this->init(&_M_filebuf);
499  this->open(__s, __mode);
500  }
501 
502 #if __cplusplus >= 201103L
503  /**
504  * @brief Create an input file stream.
505  * @param __s std::string specifying the filename.
506  * @param __mode Open file in specified mode (see std::ios_base).
507  *
508  * @c ios_base::in is automatically included in @a __mode.
509  */
510  explicit
512  ios_base::openmode __mode = ios_base::in)
513  : __istream_type(), _M_filebuf()
514  {
515  this->init(&_M_filebuf);
516  this->open(__s, __mode);
517  }
518 
519  basic_ifstream(const basic_ifstream&) = delete;
520 
522  : __istream_type(std::move(__rhs)),
523  _M_filebuf(std::move(__rhs._M_filebuf))
524  { __istream_type::set_rdbuf(&_M_filebuf); }
525 #endif
526 
527  /**
528  * @brief The destructor does nothing.
529  *
530  * The file is closed by the filebuf object, not the formatting
531  * stream.
532  */
534  { }
535 
536 #if __cplusplus >= 201103L
537  // 27.8.3.2 Assign and swap:
538 
540  operator=(const basic_ifstream&) = delete;
541 
543  operator=(basic_ifstream&& __rhs)
544  {
545  __istream_type::operator=(std::move(__rhs));
546  _M_filebuf = std::move(__rhs._M_filebuf);
547  return *this;
548  }
549 
550  void
551  swap(basic_ifstream& __rhs)
552  {
553  __istream_type::swap(__rhs);
554  _M_filebuf.swap(__rhs._M_filebuf);
555  }
556 #endif
557 
558  // Members:
559  /**
560  * @brief Accessing the underlying buffer.
561  * @return The current basic_filebuf buffer.
562  *
563  * This hides both signatures of std::basic_ios::rdbuf().
564  */
565  __filebuf_type*
566  rdbuf() const
567  { return const_cast<__filebuf_type*>(&_M_filebuf); }
568 
569  /**
570  * @brief Wrapper to test for an open file.
571  * @return @c rdbuf()->is_open()
572  */
573  bool
575  { return _M_filebuf.is_open(); }
576 
577  // _GLIBCXX_RESOLVE_LIB_DEFECTS
578  // 365. Lack of const-qualification in clause 27
579  bool
580  is_open() const
581  { return _M_filebuf.is_open(); }
582 
583  /**
584  * @brief Opens an external file.
585  * @param __s The name of the file.
586  * @param __mode The open mode flags.
587  *
588  * Calls @c std::basic_filebuf::open(s,__mode|in). If that function
589  * fails, @c failbit is set in the stream's error state.
590  *
591  * Tip: When using std::string to hold the filename, you must use
592  * .c_str() before passing it to this constructor.
593  */
594  void
595  open(const char* __s, ios_base::openmode __mode = ios_base::in)
596  {
597  if (!_M_filebuf.open(__s, __mode | ios_base::in))
598  this->setstate(ios_base::failbit);
599  else
600  // _GLIBCXX_RESOLVE_LIB_DEFECTS
601  // 409. Closing an fstream should clear error state
602  this->clear();
603  }
604 
605 #if __cplusplus >= 201103L
606  /**
607  * @brief Opens an external file.
608  * @param __s The name of the file.
609  * @param __mode The open mode flags.
610  *
611  * Calls @c std::basic_filebuf::open(__s,__mode|in). If that function
612  * fails, @c failbit is set in the stream's error state.
613  */
614  void
615  open(const std::string& __s, ios_base::openmode __mode = ios_base::in)
616  {
617  if (!_M_filebuf.open(__s, __mode | ios_base::in))
618  this->setstate(ios_base::failbit);
619  else
620  // _GLIBCXX_RESOLVE_LIB_DEFECTS
621  // 409. Closing an fstream should clear error state
622  this->clear();
623  }
624 #endif
625 
626  /**
627  * @brief Close the file.
628  *
629  * Calls @c std::basic_filebuf::close(). If that function
630  * fails, @c failbit is set in the stream's error state.
631  */
632  void
634  {
635  if (!_M_filebuf.close())
636  this->setstate(ios_base::failbit);
637  }
638  };
639 
640 
641  // [27.8.1.8] Template class basic_ofstream
642  /**
643  * @brief Controlling output for files.
644  * @ingroup io
645  *
646  * @tparam _CharT Type of character stream.
647  * @tparam _Traits Traits for character type, defaults to
648  * char_traits<_CharT>.
649  *
650  * This class supports reading from named files, using the inherited
651  * functions from std::basic_ostream. To control the associated
652  * sequence, an instance of std::basic_filebuf is used, which this page
653  * refers to as @c sb.
654  */
655  template<typename _CharT, typename _Traits>
656  class basic_ofstream : public basic_ostream<_CharT,_Traits>
657  {
658  public:
659  // Types:
660  typedef _CharT char_type;
661  typedef _Traits traits_type;
662  typedef typename traits_type::int_type int_type;
663  typedef typename traits_type::pos_type pos_type;
664  typedef typename traits_type::off_type off_type;
665 
666  // Non-standard types:
669 
670  private:
671  __filebuf_type _M_filebuf;
672 
673  public:
674  // Constructors:
675  /**
676  * @brief Default constructor.
677  *
678  * Initializes @c sb using its default constructor, and passes
679  * @c &sb to the base class initializer. Does not open any files
680  * (you haven't given it a filename to open).
681  */
682  basic_ofstream(): __ostream_type(), _M_filebuf()
683  { this->init(&_M_filebuf); }
684 
685  /**
686  * @brief Create an output file stream.
687  * @param __s Null terminated string specifying the filename.
688  * @param __mode Open file in specified mode (see std::ios_base).
689  *
690  * @c ios_base::out | @c ios_base::trunc is automatically included in
691  * @a __mode.
692  *
693  * Tip: When using std::string to hold the filename, you must use
694  * .c_str() before passing it to this constructor.
695  */
696  explicit
697  basic_ofstream(const char* __s,
698  ios_base::openmode __mode = ios_base::out|ios_base::trunc)
699  : __ostream_type(), _M_filebuf()
700  {
701  this->init(&_M_filebuf);
702  this->open(__s, __mode);
703  }
704 
705 #if __cplusplus >= 201103L
706  /**
707  * @brief Create an output file stream.
708  * @param __s std::string specifying the filename.
709  * @param __mode Open file in specified mode (see std::ios_base).
710  *
711  * @c ios_base::out | @c ios_base::trunc is automatically included in
712  * @a __mode.
713  */
714  explicit
716  ios_base::openmode __mode = ios_base::out|ios_base::trunc)
717  : __ostream_type(), _M_filebuf()
718  {
719  this->init(&_M_filebuf);
720  this->open(__s, __mode);
721  }
722 
723  basic_ofstream(const basic_ofstream&) = delete;
724 
726  : __ostream_type(std::move(__rhs)),
727  _M_filebuf(std::move(__rhs._M_filebuf))
728  { __ostream_type::set_rdbuf(&_M_filebuf); }
729 #endif
730 
731  /**
732  * @brief The destructor does nothing.
733  *
734  * The file is closed by the filebuf object, not the formatting
735  * stream.
736  */
738  { }
739 
740 #if __cplusplus >= 201103L
741  // 27.8.3.2 Assign and swap:
742 
744  operator=(const basic_ofstream&) = delete;
745 
747  operator=(basic_ofstream&& __rhs)
748  {
749  __ostream_type::operator=(std::move(__rhs));
750  _M_filebuf = std::move(__rhs._M_filebuf);
751  return *this;
752  }
753 
754  void
755  swap(basic_ofstream& __rhs)
756  {
757  __ostream_type::swap(__rhs);
758  _M_filebuf.swap(__rhs._M_filebuf);
759  }
760 #endif
761 
762  // Members:
763  /**
764  * @brief Accessing the underlying buffer.
765  * @return The current basic_filebuf buffer.
766  *
767  * This hides both signatures of std::basic_ios::rdbuf().
768  */
769  __filebuf_type*
770  rdbuf() const
771  { return const_cast<__filebuf_type*>(&_M_filebuf); }
772 
773  /**
774  * @brief Wrapper to test for an open file.
775  * @return @c rdbuf()->is_open()
776  */
777  bool
779  { return _M_filebuf.is_open(); }
780 
781  // _GLIBCXX_RESOLVE_LIB_DEFECTS
782  // 365. Lack of const-qualification in clause 27
783  bool
784  is_open() const
785  { return _M_filebuf.is_open(); }
786 
787  /**
788  * @brief Opens an external file.
789  * @param __s The name of the file.
790  * @param __mode The open mode flags.
791  *
792  * Calls @c std::basic_filebuf::open(__s,__mode|out|trunc). If that
793  * function fails, @c failbit is set in the stream's error state.
794  *
795  * Tip: When using std::string to hold the filename, you must use
796  * .c_str() before passing it to this constructor.
797  */
798  void
799  open(const char* __s,
800  ios_base::openmode __mode = ios_base::out | ios_base::trunc)
801  {
802  if (!_M_filebuf.open(__s, __mode | ios_base::out))
803  this->setstate(ios_base::failbit);
804  else
805  // _GLIBCXX_RESOLVE_LIB_DEFECTS
806  // 409. Closing an fstream should clear error state
807  this->clear();
808  }
809 
810 #if __cplusplus >= 201103L
811  /**
812  * @brief Opens an external file.
813  * @param __s The name of the file.
814  * @param __mode The open mode flags.
815  *
816  * Calls @c std::basic_filebuf::open(s,mode|out|trunc). If that
817  * function fails, @c failbit is set in the stream's error state.
818  */
819  void
820  open(const std::string& __s,
821  ios_base::openmode __mode = ios_base::out | ios_base::trunc)
822  {
823  if (!_M_filebuf.open(__s, __mode | ios_base::out))
824  this->setstate(ios_base::failbit);
825  else
826  // _GLIBCXX_RESOLVE_LIB_DEFECTS
827  // 409. Closing an fstream should clear error state
828  this->clear();
829  }
830 #endif
831 
832  /**
833  * @brief Close the file.
834  *
835  * Calls @c std::basic_filebuf::close(). If that function
836  * fails, @c failbit is set in the stream's error state.
837  */
838  void
840  {
841  if (!_M_filebuf.close())
842  this->setstate(ios_base::failbit);
843  }
844  };
845 
846 
847  // [27.8.1.11] Template class basic_fstream
848  /**
849  * @brief Controlling input and output for files.
850  * @ingroup io
851  *
852  * @tparam _CharT Type of character stream.
853  * @tparam _Traits Traits for character type, defaults to
854  * char_traits<_CharT>.
855  *
856  * This class supports reading from and writing to named files, using
857  * the inherited functions from std::basic_iostream. To control the
858  * associated sequence, an instance of std::basic_filebuf is used, which
859  * this page refers to as @c sb.
860  */
861  template<typename _CharT, typename _Traits>
862  class basic_fstream : public basic_iostream<_CharT, _Traits>
863  {
864  public:
865  // Types:
866  typedef _CharT char_type;
867  typedef _Traits traits_type;
868  typedef typename traits_type::int_type int_type;
869  typedef typename traits_type::pos_type pos_type;
870  typedef typename traits_type::off_type off_type;
871 
872  // Non-standard types:
876 
877  private:
878  __filebuf_type _M_filebuf;
879 
880  public:
881  // Constructors/destructor:
882  /**
883  * @brief Default constructor.
884  *
885  * Initializes @c sb using its default constructor, and passes
886  * @c &sb to the base class initializer. Does not open any files
887  * (you haven't given it a filename to open).
888  */
890  : __iostream_type(), _M_filebuf()
891  { this->init(&_M_filebuf); }
892 
893  /**
894  * @brief Create an input/output file stream.
895  * @param __s Null terminated string specifying the filename.
896  * @param __mode Open file in specified mode (see std::ios_base).
897  *
898  * Tip: When using std::string to hold the filename, you must use
899  * .c_str() before passing it to this constructor.
900  */
901  explicit
902  basic_fstream(const char* __s,
903  ios_base::openmode __mode = ios_base::in | ios_base::out)
904  : __iostream_type(0), _M_filebuf()
905  {
906  this->init(&_M_filebuf);
907  this->open(__s, __mode);
908  }
909 
910 #if __cplusplus >= 201103L
911  /**
912  * @brief Create an input/output file stream.
913  * @param __s Null terminated string specifying the filename.
914  * @param __mode Open file in specified mode (see std::ios_base).
915  */
916  explicit
918  ios_base::openmode __mode = ios_base::in | ios_base::out)
919  : __iostream_type(0), _M_filebuf()
920  {
921  this->init(&_M_filebuf);
922  this->open(__s, __mode);
923  }
924 
925  basic_fstream(const basic_fstream&) = delete;
926 
928  : __iostream_type(std::move(__rhs)),
929  _M_filebuf(std::move(__rhs._M_filebuf))
930  { __iostream_type::set_rdbuf(&_M_filebuf); }
931 #endif
932 
933  /**
934  * @brief The destructor does nothing.
935  *
936  * The file is closed by the filebuf object, not the formatting
937  * stream.
938  */
940  { }
941 
942 #if __cplusplus >= 201103L
943  // 27.8.3.2 Assign and swap:
944 
946  operator=(const basic_fstream&) = delete;
947 
949  operator=(basic_fstream&& __rhs)
950  {
951  __iostream_type::operator=(std::move(__rhs));
952  _M_filebuf = std::move(__rhs._M_filebuf);
953  return *this;
954  }
955 
956  void
957  swap(basic_fstream& __rhs)
958  {
959  __iostream_type::swap(__rhs);
960  _M_filebuf.swap(__rhs._M_filebuf);
961  }
962 #endif
963 
964  // Members:
965  /**
966  * @brief Accessing the underlying buffer.
967  * @return The current basic_filebuf buffer.
968  *
969  * This hides both signatures of std::basic_ios::rdbuf().
970  */
971  __filebuf_type*
972  rdbuf() const
973  { return const_cast<__filebuf_type*>(&_M_filebuf); }
974 
975  /**
976  * @brief Wrapper to test for an open file.
977  * @return @c rdbuf()->is_open()
978  */
979  bool
981  { return _M_filebuf.is_open(); }
982 
983  // _GLIBCXX_RESOLVE_LIB_DEFECTS
984  // 365. Lack of const-qualification in clause 27
985  bool
986  is_open() const
987  { return _M_filebuf.is_open(); }
988 
989  /**
990  * @brief Opens an external file.
991  * @param __s The name of the file.
992  * @param __mode The open mode flags.
993  *
994  * Calls @c std::basic_filebuf::open(__s,__mode). If that
995  * function fails, @c failbit is set in the stream's error state.
996  *
997  * Tip: When using std::string to hold the filename, you must use
998  * .c_str() before passing it to this constructor.
999  */
1000  void
1001  open(const char* __s,
1002  ios_base::openmode __mode = ios_base::in | ios_base::out)
1003  {
1004  if (!_M_filebuf.open(__s, __mode))
1005  this->setstate(ios_base::failbit);
1006  else
1007  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1008  // 409. Closing an fstream should clear error state
1009  this->clear();
1010  }
1011 
1012 #if __cplusplus >= 201103L
1013  /**
1014  * @brief Opens an external file.
1015  * @param __s The name of the file.
1016  * @param __mode The open mode flags.
1017  *
1018  * Calls @c std::basic_filebuf::open(__s,__mode). If that
1019  * function fails, @c failbit is set in the stream's error state.
1020  */
1021  void
1022  open(const std::string& __s,
1023  ios_base::openmode __mode = ios_base::in | ios_base::out)
1024  {
1025  if (!_M_filebuf.open(__s, __mode))
1026  this->setstate(ios_base::failbit);
1027  else
1028  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1029  // 409. Closing an fstream should clear error state
1030  this->clear();
1031  }
1032 #endif
1033 
1034  /**
1035  * @brief Close the file.
1036  *
1037  * Calls @c std::basic_filebuf::close(). If that function
1038  * fails, @c failbit is set in the stream's error state.
1039  */
1040  void
1042  {
1043  if (!_M_filebuf.close())
1044  this->setstate(ios_base::failbit);
1045  }
1046  };
1047 
1048 #if __cplusplus >= 201103L
1049  /// Swap specialization for filebufs.
1050  template <class _CharT, class _Traits>
1051  inline void
1054  { __x.swap(__y); }
1055 
1056  /// Swap specialization for ifstreams.
1057  template <class _CharT, class _Traits>
1058  inline void
1061  { __x.swap(__y); }
1062 
1063  /// Swap specialization for ofstreams.
1064  template <class _CharT, class _Traits>
1065  inline void
1068  { __x.swap(__y); }
1069 
1070  /// Swap specialization for fstreams.
1071  template <class _CharT, class _Traits>
1072  inline void
1075  { __x.swap(__y); }
1076 #endif
1077 
1078 _GLIBCXX_END_NAMESPACE_VERSION
1079 } // namespace
1080 
1081 #include <bits/fstream.tcc>
1082 
1083 #endif /* _GLIBCXX_FSTREAM */
void setg(char_type *__gbeg, char_type *__gnext, char_type *__gend)
Setting the three read area pointers.
Definition: streambuf:509
char_type * egptr() const
Access to the get area.
Definition: streambuf:488
Controlling output for files.
Definition: fstream:656
Template class basic_iostream.
Definition: iosfwd:89
static const openmode app
Seek to end before each write.
Definition: ios_base.h:432
char_type * _M_pback_end_save
Definition: fstream:158
static const iostate failbit
Indicates that an input operation failed to read the expected characters, or that an output operation...
Definition: ios_base.h:410
char_type * eback() const
Access to the get area.
Definition: streambuf:482
char_type * _M_pback_cur_save
Definition: fstream:157
~basic_ofstream()
The destructor does nothing.
Definition: fstream:737
Primary class template codecvt.NB: Generic, mostly useless implementation.
Definition: codecvt.h:274
char * _M_ext_buf
Definition: fstream:170
void close()
Close the file.
Definition: fstream:839
char_type * _M_buf
Pointer to the beginning of internal buffer.
Definition: fstream:128
virtual void imbue(const locale &__loc)
Changes translations.
Definition: fstream.tcc:997
The actual work of input and output (interface).
Definition: iosfwd:80
bool is_open()
Wrapper to test for an open file.
Definition: fstream:778
void open(const std::string &__s, ios_base::openmode __mode=ios_base::out|ios_base::trunc)
Opens an external file.
Definition: fstream:820
ISO C++ entities toplevel namespace is std.
void open(const char *__s, ios_base::openmode __mode=ios_base::in)
Opens an external file.
Definition: fstream:595
virtual streamsize showmanyc()
Investigating the data available.
Definition: fstream.tcc:263
virtual streamsize xsgetn(char_type *__s, streamsize __n)
Multiple character extraction.
Definition: fstream.tcc:635
__filebuf_type * rdbuf() const
Accessing the underlying buffer.
Definition: fstream:972
void open(const std::string &__s, ios_base::openmode __mode=ios_base::in)
Opens an external file.
Definition: fstream:615
basic_filebuf()
Does not open any files.
Definition: fstream.tcc:80
virtual int sync()
Synchronizes the buffer arrays with the controlled sequences.
Definition: fstream.tcc:980
virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode=ios_base::in|ios_base::out)
Alters the stream positions.
Definition: fstream.tcc:800
Controlling input for files.
Definition: fstream:455
virtual streamsize xsputn(const char_type *__s, streamsize __n)
Multiple character insertion.
Definition: fstream.tcc:723
Template class basic_ostream.
Definition: iosfwd:86
__filebuf_type * rdbuf() const
Accessing the underlying buffer.
Definition: fstream:566
Template class basic_ios, virtual base class for all stream classes.
Definition: iosfwd:77
__filebuf_type * open(const std::string &__s, ios_base::openmode __mode)
Opens an external file.
Definition: fstream:307
~basic_fstream()
The destructor does nothing.
Definition: fstream:939
void _M_create_pback()
Definition: fstream:191
virtual int_type underflow()
Fetches more data from the controlled sequence.
Definition: fstream.tcc:289
static const openmode trunc
Open for input. Default for ofstream.
Definition: ios_base.h:449
Controlling input and output for files.
Definition: fstream:862
bool _M_pback_init
Definition: fstream:159
char_type _M_pback
Definition: fstream:156
ios_base::openmode _M_mode
Place to stash in || out || in | out settings for current filebuf.
Definition: fstream:113
basic_fstream(const char *__s, ios_base::openmode __mode=ios_base::in|ios_base::out)
Create an input/output file stream.
Definition: fstream:902
void open(const char *__s, ios_base::openmode __mode=ios_base::in|ios_base::out)
Opens an external file.
Definition: fstream:1001
~basic_ifstream()
The destructor does nothing.
Definition: fstream:533
virtual int_type pbackfail(int_type __c=_Traits::eof())
Tries to back up the input sequence.
Definition: fstream.tcc:448
void _M_set_buffer(streamsize __off)
Definition: fstream:422
basic_ofstream(const char *__s, ios_base::openmode __mode=ios_base::out|ios_base::trunc)
Create an output file stream.
Definition: fstream:697
basic_ifstream(const char *__s, ios_base::openmode __mode=ios_base::in)
Create an input file stream.
Definition: fstream:495
basic_ifstream()
Default constructor.
Definition: fstream:481
basic_fstream()
Default constructor.
Definition: fstream:889
void open(const char *__s, ios_base::openmode __mode=ios_base::out|ios_base::trunc)
Opens an external file.
Definition: fstream:799
const char * _M_ext_next
Definition: fstream:182
The base of the I/O class hierarchy.This class defines everything that can be defined about I/O that ...
Definition: ios_base.h:228
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:98
static const openmode in
Open for input. Default for ifstream and fstream.
Definition: ios_base.h:443
__filebuf_type * close()
Closes the currently associated file.
Definition: fstream.tcc:213
Class representing stream positions.
Definition: postypes.h:112
virtual int_type overflow(int_type __c=_Traits::eof())
Consumes data from the buffer; writes to the controlled sequence.
Definition: fstream.tcc:507
void swap(basic_fstream< _CharT, _Traits > &__x, basic_fstream< _CharT, _Traits > &__y)
Swap specialization for fstreams.
Definition: fstream:1073
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
void _M_destroy_pback()
Definition: fstream:208
virtual __streambuf_type * setbuf(char_type *__s, streamsize __n)
Manipulates the buffer.
Definition: fstream.tcc:771
virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode=ios_base::in|ios_base::out)
Alters the stream positions.
Definition: fstream.tcc:860
Container class for localization functionality.The locale class is first a class wrapper for C librar...
bool is_open()
Wrapper to test for an open file.
Definition: fstream:980
void open(const std::string &__s, ios_base::openmode __mode=ios_base::in|ios_base::out)
Opens an external file.
Definition: fstream:1022
void close()
Close the file.
Definition: fstream:1041
__filebuf_type * rdbuf() const
Accessing the underlying buffer.
Definition: fstream:770
static const openmode out
Open for output. Default for ofstream and fstream.
Definition: ios_base.h:446
bool is_open() const
Returns true if the external file is open.
Definition: fstream:252
streamsize _M_ext_buf_size
Definition: fstream:175
basic_ifstream(const std::string &__s, ios_base::openmode __mode=ios_base::in)
Create an input file stream.
Definition: fstream:511
__filebuf_type * open(const char *__s, ios_base::openmode __mode)
Opens an external file.
Definition: fstream.tcc:179
void setp(char_type *__pbeg, char_type *__pend)
Setting the three write area pointers.
Definition: streambuf:555
basic_ofstream(const std::string &__s, ios_base::openmode __mode=ios_base::out|ios_base::trunc)
Create an output file stream.
Definition: fstream:715
The actual work of input and output (for files).
Definition: fstream:72
virtual ~basic_filebuf()
The destructor closes the file first.
Definition: fstream:238
Template class basic_istream.
Definition: iosfwd:83
char_type * gptr() const
Access to the get area.
Definition: streambuf:485
basic_fstream(const std::string &__s, ios_base::openmode __mode=ios_base::in|ios_base::out)
Create an input/output file stream.
Definition: fstream:917
size_t _M_buf_size
Definition: fstream:135
basic_ofstream()
Default constructor.
Definition: fstream:682
bool is_open()
Wrapper to test for an open file.
Definition: fstream:574
void close()
Close the file.
Definition: fstream:633