1// File based streams -*- C++ -*- 
2 
3// Copyright (C) 1997-2019 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 
47namespace std _GLIBCXX_VISIBILITY(default) 
48{ 
49_GLIBCXX_BEGIN_NAMESPACE_VERSION 
50 
51#if __cplusplus >= 201703L 
52 // Enable if _Path is a filesystem::path or experimental::filesystem::path 
53 template<typename _Path, typename _Result = _Path, typename _Path2 
54 = decltype(std::declval<_Path&>().make_preferred().filename())> 
55 using _If_fs_path = enable_if_t<is_same_v<_Path, _Path2>, _Result>; 
56#endif // C++17 
57 
58 
59 // [27.8.1.1] template class basic_filebuf 
60 /** 
61 * @brief The actual work of input and output (for files). 
62 * @ingroup io 
63 * 
64 * @tparam _CharT Type of character stream. 
65 * @tparam _Traits Traits for character type, defaults to 
66 * char_traits<_CharT>. 
67 * 
68 * This class associates both its input and output sequence with an 
69 * external disk file, and maintains a joint file position for both 
70 * sequences. Many of its semantics are described in terms of similar 
71 * behavior in the Standard C Library's @c FILE streams. 
72 * 
73 * Requirements on traits_type, specific to this class: 
74 * - traits_type::pos_type must be fpos<traits_type::state_type> 
75 * - traits_type::off_type must be streamoff 
76 * - traits_type::state_type must be Assignable and DefaultConstructible, 
77 * - traits_type::state_type() must be the initial state for codecvt. 
78 */ 
79 template<typename _CharT, typename _Traits> 
80 class basic_filebuf : public basic_streambuf<_CharT, _Traits> 
81 { 
82#if __cplusplus >= 201103L 
83 template<typename _Tp> 
84 using __chk_state = __and_<is_copy_assignable<_Tp>, 
85 is_copy_constructible<_Tp>, 
86 is_default_constructible<_Tp>>; 
87 
88 static_assert(__chk_state<typename _Traits::state_type>::value, 
89 "state_type must be CopyAssignable, CopyConstructible" 
90 " and DefaultConstructible"); 
91 
92 static_assert(is_same<typename _Traits::pos_type, 
93 fpos<typename _Traits::state_type>>::value, 
94 "pos_type must be fpos<state_type>"); 
95#endif 
96 public: 
97 // Types: 
98 typedef _CharT char_type; 
99 typedef _Traits traits_type; 
100 typedef typename traits_type::int_type int_type; 
101 typedef typename traits_type::pos_type pos_type; 
102 typedef typename traits_type::off_type off_type; 
103 
104 typedef basic_streambuf<char_type, traits_type> __streambuf_type; 
105 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 
106 typedef __basic_file<char> __file_type; 
107 typedef typename traits_type::state_type __state_type; 
108 typedef codecvt<char_type, char, __state_type> __codecvt_type; 
109 
110 friend class ios_base; // For sync_with_stdio. 
111 
112 protected: 
113 // Data Members: 
114 // MT lock inherited from libio or other low-level io library. 
115 __c_lock _M_lock; 
116 
117 // External buffer. 
118 __file_type _M_file; 
119 
120 /// Place to stash in || out || in | out settings for current filebuf. 
121 ios_base::openmode _M_mode; 
122 
123 // Beginning state type for codecvt. 
124 __state_type _M_state_beg; 
125 
126 // During output, the state that corresponds to pptr(), 
127 // during input, the state that corresponds to egptr() and 
128 // _M_ext_next. 
129 __state_type _M_state_cur; 
130 
131 // Not used for output. During input, the state that corresponds 
132 // to eback() and _M_ext_buf. 
133 __state_type _M_state_last; 
134 
135 /// Pointer to the beginning of internal buffer. 
136 char_type* _M_buf; 
137 
138 /** 
139 * Actual size of internal buffer. This number is equal to the size 
140 * of the put area + 1 position, reserved for the overflow char of 
141 * a full area. 
142 */ 
143 size_t _M_buf_size; 
144 
145 // Set iff _M_buf is allocated memory from _M_allocate_internal_buffer. 
146 bool _M_buf_allocated; 
147 
148 /** 
149 * _M_reading == false && _M_writing == false for @b uncommitted mode; 
150 * _M_reading == true for @b read mode; 
151 * _M_writing == true for @b write mode; 
152 * 
153 * NB: _M_reading == true && _M_writing == true is unused. 
154 */ 
155 bool _M_reading; 
156 bool _M_writing; 
157 
158 //@{ 
159 /** 
160 * Necessary bits for putback buffer management. 
161 * 
162 * @note pbacks of over one character are not currently supported. 
163 */ 
164 char_type _M_pback; 
165 char_type* _M_pback_cur_save; 
166 char_type* _M_pback_end_save; 
167 bool _M_pback_init; 
168 //@} 
169 
170 // Cached codecvt facet. 
171 const __codecvt_type* _M_codecvt; 
172 
173 /** 
174 * Buffer for external characters. Used for input when 
175 * codecvt::always_noconv() == false. When valid, this corresponds 
176 * to eback(). 
177 */ 
178 char* _M_ext_buf; 
179 
180 /** 
181 * Size of buffer held by _M_ext_buf. 
182 */ 
183 streamsize _M_ext_buf_size; 
184 
185 /** 
186 * Pointers into the buffer held by _M_ext_buf that delimit a 
187 * subsequence of bytes that have been read but not yet converted. 
188 * When valid, _M_ext_next corresponds to egptr(). 
189 */ 
190 const char* _M_ext_next; 
191 char* _M_ext_end; 
192 
193 /** 
194 * Initializes pback buffers, and moves normal buffers to safety. 
195 * Assumptions: 
196 * _M_in_cur has already been moved back 
197 */ 
198 void 
199 _M_create_pback() 
200 { 
201 if (!_M_pback_init) 
202 { 
203 _M_pback_cur_save = this->gptr(); 
204 _M_pback_end_save = this->egptr(); 
205 this->setg(&_M_pback, &_M_pback, &_M_pback + 1); 
206 _M_pback_init = true; 
207 } 
208 } 
209 
210 /** 
211 * Deactivates pback buffer contents, and restores normal buffer. 
212 * Assumptions: 
213 * The pback buffer has only moved forward. 
214 */ 
215 void 
216 _M_destroy_pback() throw() 
217 { 
218 if (_M_pback_init) 
219 { 
220 // Length _M_in_cur moved in the pback buffer. 
221 _M_pback_cur_save += this->gptr() != this->eback(); 
222 this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save); 
223 _M_pback_init = false; 
224 } 
225 } 
226 
227 public: 
228 // Constructors/destructor: 
229 /** 
230 * @brief Does not open any files. 
231 * 
232 * The default constructor initializes the parent class using its 
233 * own default ctor. 
234 */ 
235 basic_filebuf(); 
236 
237#if __cplusplus >= 201103L 
238 basic_filebuf(const basic_filebuf&) = delete; 
239 basic_filebuf(basic_filebuf&&); 
240#endif 
241 
242 /** 
243 * @brief The destructor closes the file first. 
244 */ 
245 virtual 
246 ~basic_filebuf() 
247 { 
248 __try 
249 { this->close(); } 
250 __catch(...) 
251 { } 
252 } 
253 
254#if __cplusplus >= 201103L 
255 basic_filebuf& operator=(const basic_filebuf&) = delete; 
256 basic_filebuf& operator=(basic_filebuf&&); 
257 void swap(basic_filebuf&); 
258#endif 
259 
260 // Members: 
261 /** 
262 * @brief Returns true if the external file is open. 
263 */ 
264 bool 
265 is_open() const throw() 
266 { return _M_file.is_open(); } 
267 
268 /** 
269 * @brief Opens an external file. 
270 * @param __s The name of the file. 
271 * @param __mode The open mode flags. 
272 * @return @c this on success, NULL on failure 
273 * 
274 * If a file is already open, this function immediately fails. 
275 * Otherwise it tries to open the file named @a __s using the flags 
276 * given in @a __mode. 
277 * 
278 * Table 92, adapted here, gives the relation between openmode 
279 * combinations and the equivalent @c fopen() flags. 
280 * (NB: lines app, in|out|app, in|app, binary|app, binary|in|out|app, 
281 * and binary|in|app per DR 596) 
282 * <pre> 
283 * +---------------------------------------------------------+ 
284 * | ios_base Flag combination stdio equivalent | 
285 * |binary in out trunc app | 
286 * +---------------------------------------------------------+ 
287 * | + w | 
288 * | + + a | 
289 * | + a | 
290 * | + + w | 
291 * | + r | 
292 * | + + r+ | 
293 * | + + + w+ | 
294 * | + + + a+ | 
295 * | + + a+ | 
296 * +---------------------------------------------------------+ 
297 * | + + wb | 
298 * | + + + ab | 
299 * | + + ab | 
300 * | + + + wb | 
301 * | + + rb | 
302 * | + + + r+b | 
303 * | + + + + w+b | 
304 * | + + + + a+b | 
305 * | + + + a+b | 
306 * +---------------------------------------------------------+ 
307 * </pre> 
308 */ 
309 __filebuf_type* 
310 open(const char* __s, ios_base::openmode __mode); 
311 
312#if _GLIBCXX_HAVE__WFOPEN && _GLIBCXX_USE_WCHAR_T 
313 /** 
314 * @brief Opens an external file. 
315 * @param __s The name of the file, as a wide character string. 
316 * @param __mode The open mode flags. 
317 * @return @c this on success, NULL on failure 
318 */ 
319 __filebuf_type* 
320 open(const wchar_t* __s, ios_base::openmode __mode); 
321#endif 
322 
323#if __cplusplus >= 201103L 
324 /** 
325 * @brief Opens an external file. 
326 * @param __s The name of the file. 
327 * @param __mode The open mode flags. 
328 * @return @c this on success, NULL on failure 
329 */ 
330 __filebuf_type* 
331 open(const std::string& __s, ios_base::openmode __mode) 
332 { return open(__s.c_str(), __mode); } 
333 
334#if __cplusplus >= 201703L 
335 /** 
336 * @brief Opens an external file. 
337 * @param __s The name of the file, as a filesystem::path. 
338 * @param __mode The open mode flags. 
339 * @return @c this on success, NULL on failure 
340 */ 
341 template<typename _Path> 
342 _If_fs_path<_Path, __filebuf_type*> 
343 open(const _Path& __s, ios_base::openmode __mode) 
344 { return open(__s.c_str(), __mode); } 
345#endif // C++17 
346#endif // C++11 
347 
348 /** 
349 * @brief Closes the currently associated file. 
350 * @return @c this on success, NULL on failure 
351 * 
352 * If no file is currently open, this function immediately fails. 
353 * 
354 * If a <em>put buffer area</em> exists, @c overflow(eof) is 
355 * called to flush all the characters. The file is then 
356 * closed. 
357 * 
358 * If any operations fail, this function also fails. 
359 */ 
360 __filebuf_type* 
361 close(); 
362 
363 protected: 
364 void 
365 _M_allocate_internal_buffer(); 
366 
367 void 
368 _M_destroy_internal_buffer() throw(); 
369 
370 // [27.8.1.4] overridden virtual functions 
371 virtual streamsize 
372 showmanyc(); 
373 
374 // Stroustrup, 1998, p. 628 
375 // underflow() and uflow() functions are called to get the next 
376 // character from the real input source when the buffer is empty. 
377 // Buffered input uses underflow() 
378 
379 virtual int_type 
380 underflow(); 
381 
382 virtual int_type 
383 pbackfail(int_type __c = _Traits::eof()); 
384 
385 // Stroustrup, 1998, p 648 
386 // The overflow() function is called to transfer characters to the 
387 // real output destination when the buffer is full. A call to 
388 // overflow(c) outputs the contents of the buffer plus the 
389 // character c. 
390 // 27.5.2.4.5 
391 // Consume some sequence of the characters in the pending sequence. 
392 virtual int_type 
393 overflow(int_type __c = _Traits::eof()); 
394 
395 // Convert internal byte sequence to external, char-based 
396 // sequence via codecvt. 
397 bool 
398 _M_convert_to_external(char_type*, streamsize); 
399 
400 /** 
401 * @brief Manipulates the buffer. 
402 * @param __s Pointer to a buffer area. 
403 * @param __n Size of @a __s. 
404 * @return @c this 
405 * 
406 * If no file has been opened, and both @a __s and @a __n are zero, then 
407 * the stream becomes unbuffered. Otherwise, @c __s is used as a 
408 * buffer; see 
409 * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering 
410 * for more. 
411 */ 
412 virtual __streambuf_type* 
413 setbuf(char_type* __s, streamsize __n); 
414 
415 virtual pos_type 
416 seekoff(off_type __off, ios_base::seekdir __way, 
417 ios_base::openmode __mode = ios_base::in | ios_base::out); 
418 
419 virtual pos_type 
420 seekpos(pos_type __pos, 
421 ios_base::openmode __mode = ios_base::in | ios_base::out); 
422 
423 // Common code for seekoff, seekpos, and overflow 
424 pos_type 
425 _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state); 
426 
427 int 
428 _M_get_ext_pos(__state_type &__state); 
429 
430 virtual int 
431 sync(); 
432 
433 virtual void 
434 imbue(const locale& __loc); 
435 
436 virtual streamsize 
437 xsgetn(char_type* __s, streamsize __n); 
438 
439 virtual streamsize 
440 xsputn(const char_type* __s, streamsize __n); 
441 
442 // Flushes output buffer, then writes unshift sequence. 
443 bool 
444 _M_terminate_output(); 
445 
446 /** 
447 * This function sets the pointers of the internal buffer, both get 
448 * and put areas. Typically: 
449 * 
450 * __off == egptr() - eback() upon underflow/uflow (@b read mode); 
451 * __off == 0 upon overflow (@b write mode); 
452 * __off == -1 upon open, setbuf, seekoff/pos (@b uncommitted mode). 
453 * 
454 * NB: epptr() - pbase() == _M_buf_size - 1, since _M_buf_size 
455 * reflects the actual allocated memory and the last cell is reserved 
456 * for the overflow char of a full put area. 
457 */ 
458 void 
459 _M_set_buffer(streamsize __off) 
460 { 
461 const bool __testin = _M_mode & ios_base::in; 
462 const bool __testout = (_M_mode & ios_base::out 
463 || _M_mode & ios_base::app); 
464 
465 if (__testin && __off > 0) 
466 this->setg(_M_buf, _M_buf, _M_buf + __off); 
467 else 
468 this->setg(_M_buf, _M_buf, _M_buf); 
469 
470 if (__testout && __off == 0 && _M_buf_size > 1 ) 
471 this->setp(_M_buf, _M_buf + _M_buf_size - 1); 
472 else 
473 this->setp(0, 0); 
474 } 
475 }; 
476 
477 // [27.8.1.5] Template class basic_ifstream 
478 /** 
479 * @brief Controlling input for files. 
480 * @ingroup io 
481 * 
482 * @tparam _CharT Type of character stream. 
483 * @tparam _Traits Traits for character type, defaults to 
484 * char_traits<_CharT>. 
485 * 
486 * This class supports reading from named files, using the inherited 
487 * functions from std::basic_istream. To control the associated 
488 * sequence, an instance of std::basic_filebuf is used, which this page 
489 * refers to as @c sb. 
490 */ 
491 template<typename _CharT, typename _Traits> 
492 class basic_ifstream : public basic_istream<_CharT, _Traits> 
493 { 
494 public: 
495 // Types: 
496 typedef _CharT char_type; 
497 typedef _Traits traits_type; 
498 typedef typename traits_type::int_type int_type; 
499 typedef typename traits_type::pos_type pos_type; 
500 typedef typename traits_type::off_type off_type; 
501 
502 // Non-standard types: 
503 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 
504 typedef basic_istream<char_type, traits_type> __istream_type; 
505 
506 private: 
507 __filebuf_type _M_filebuf; 
508 
509 public: 
510 // Constructors/Destructors: 
511 /** 
512 * @brief Default constructor. 
513 * 
514 * Initializes @c sb using its default constructor, and passes 
515 * @c &sb to the base class initializer. Does not open any files 
516 * (you haven't given it a filename to open). 
517 */ 
518 basic_ifstream() : __istream_type(), _M_filebuf() 
519 { this->init(&_M_filebuf); } 
520 
521 /** 
522 * @brief Create an input file stream. 
523 * @param __s Null terminated string specifying the filename. 
524 * @param __mode Open file in specified mode (see std::ios_base). 
525 * 
526 * @c ios_base::in is automatically included in @a __mode. 
527 */ 
528 explicit 
529 basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in) 
530 : __istream_type(), _M_filebuf() 
531 { 
532 this->init(&_M_filebuf); 
533 this->open(__s, __mode); 
534 } 
535 
536#if _GLIBCXX_HAVE__WFOPEN && _GLIBCXX_USE_WCHAR_T 
537 /** 
538 * @param Create an input file stream. 
539 * @param __s Wide string specifying the filename. 
540 * @param __mode Open file in specified mode (see std::ios_base). 
541 * 
542 * @c ios_base::in is automatically included in @a __mode. 
543 */ 
544 basic_ifstream(const wchar_t* __s, 
545 ios_base::openmode __mode = ios_base::in) 
546 : __istream_type(), _M_filebuf() 
547 { 
548 this->init(&_M_filebuf); 
549 this->open(__s, __mode); 
550 } 
551#endif 
552 
553#if __cplusplus >= 201103L 
554 /** 
555 * @brief Create an input file stream. 
556 * @param __s std::string specifying the filename. 
557 * @param __mode Open file in specified mode (see std::ios_base). 
558 * 
559 * @c ios_base::in is automatically included in @a __mode. 
560 */ 
561 explicit 
562 basic_ifstream(const std::string& __s, 
563 ios_base::openmode __mode = ios_base::in) 
564 : __istream_type(), _M_filebuf() 
565 { 
566 this->init(&_M_filebuf); 
567 this->open(__s, __mode); 
568 } 
569 
570#if __cplusplus >= 201703L 
571 /** 
572 * @param Create an input file stream. 
573 * @param __s filesystem::path specifying the filename. 
574 * @param __mode Open file in specified mode (see std::ios_base). 
575 * 
576 * @c ios_base::in is automatically included in @a __mode. 
577 */ 
578 template<typename _Path, typename _Require = _If_fs_path<_Path>> 
579 basic_ifstream(const _Path& __s, 
580 ios_base::openmode __mode = ios_base::in) 
581 : basic_ifstream(__s.c_str(), __mode) 
582 { } 
583#endif // C++17 
584 
585 basic_ifstream(const basic_ifstream&) = delete; 
586 
587 basic_ifstream(basic_ifstream&& __rhs) 
588 : __istream_type(std::move(__rhs)), 
589 _M_filebuf(std::move(__rhs._M_filebuf)) 
590 { __istream_type::set_rdbuf(&_M_filebuf); } 
591#endif // C++11 
592 
593 /** 
594 * @brief The destructor does nothing. 
595 * 
596 * The file is closed by the filebuf object, not the formatting 
597 * stream. 
598 */ 
599 ~basic_ifstream() 
600 { } 
601 
602#if __cplusplus >= 201103L 
603 // 27.8.3.2 Assign and swap: 
604 
605 basic_ifstream& 
606 operator=(const basic_ifstream&) = delete; 
607 
608 basic_ifstream& 
609 operator=(basic_ifstream&& __rhs) 
610 { 
611 __istream_type::operator=(std::move(__rhs)); 
612 _M_filebuf = std::move(__rhs._M_filebuf); 
613 return *this; 
614 } 
615 
616 void 
617 swap(basic_ifstream& __rhs) 
618 { 
619 __istream_type::swap(__rhs); 
620 _M_filebuf.swap(__rhs._M_filebuf); 
621 } 
622#endif 
623 
624 // Members: 
625 /** 
626 * @brief Accessing the underlying buffer. 
627 * @return The current basic_filebuf buffer. 
628 * 
629 * This hides both signatures of std::basic_ios::rdbuf(). 
630 */ 
631 __filebuf_type* 
632 rdbuf() const 
633 { return const_cast<__filebuf_type*>(&_M_filebuf); } 
634 
635 /** 
636 * @brief Wrapper to test for an open file. 
637 * @return @c rdbuf()->is_open() 
638 */ 
639 bool 
640 is_open() 
641 { return _M_filebuf.is_open(); } 
642 
643 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
644 // 365. Lack of const-qualification in clause 27 
645 bool 
646 is_open() const 
647 { return _M_filebuf.is_open(); } 
648 
649 /** 
650 * @brief Opens an external file. 
651 * @param __s The name of the file. 
652 * @param __mode The open mode flags. 
653 * 
654 * Calls @c std::basic_filebuf::open(s,__mode|in). If that function 
655 * fails, @c failbit is set in the stream's error state. 
656 */ 
657 void 
658 open(const char* __s, ios_base::openmode __mode = ios_base::in) 
659 { 
660 if (!_M_filebuf.open(__s, __mode | ios_base::in)) 
661 this->setstate(ios_base::failbit); 
662 else 
663 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
664 // 409. Closing an fstream should clear error state 
665 this->clear(); 
666 } 
667 
668#if _GLIBCXX_HAVE__WFOPEN && _GLIBCXX_USE_WCHAR_T 
669 /** 
670 * @brief Opens an external file. 
671 * @param __s The name of the file, as a wide character string. 
672 * @param __mode The open mode flags. 
673 * 
674 * Calls @c std::basic_filebuf::open(__s,__mode|in). If that function 
675 * fails, @c failbit is set in the stream's error state. 
676 */ 
677 void 
678 open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in) 
679 { 
680 if (!_M_filebuf.open(__s, __mode | ios_base::in)) 
681 this->setstate(ios_base::failbit); 
682 else 
683 this->clear(); 
684 } 
685#endif 
686 
687#if __cplusplus >= 201103L 
688 /** 
689 * @brief Opens an external file. 
690 * @param __s The name of the file. 
691 * @param __mode The open mode flags. 
692 * 
693 * Calls @c std::basic_filebuf::open(__s,__mode|in). If that function 
694 * fails, @c failbit is set in the stream's error state. 
695 */ 
696 void 
697 open(const std::string& __s, ios_base::openmode __mode = ios_base::in) 
698 { 
699 if (!_M_filebuf.open(__s, __mode | ios_base::in)) 
700 this->setstate(ios_base::failbit); 
701 else 
702 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
703 // 409. Closing an fstream should clear error state 
704 this->clear(); 
705 } 
706 
707#if __cplusplus >= 201703L 
708 /** 
709 * @brief Opens an external file. 
710 * @param __s The name of the file, as a filesystem::path. 
711 * @param __mode The open mode flags. 
712 * 
713 * Calls @c std::basic_filebuf::open(__s,__mode|in). If that function 
714 * fails, @c failbit is set in the stream's error state. 
715 */ 
716 template<typename _Path> 
717 _If_fs_path<_Path, void> 
718 open(const _Path& __s, ios_base::openmode __mode = ios_base::in) 
719 { open(__s.c_str(), __mode); } 
720#endif // C++17 
721#endif // C++11 
722 
723 /** 
724 * @brief Close the file. 
725 * 
726 * Calls @c std::basic_filebuf::close(). If that function 
727 * fails, @c failbit is set in the stream's error state. 
728 */ 
729 void 
730 close() 
731 { 
732 if (!_M_filebuf.close()) 
733 this->setstate(ios_base::failbit); 
734 } 
735 }; 
736 
737 
738 // [27.8.1.8] Template class basic_ofstream 
739 /** 
740 * @brief Controlling output for files. 
741 * @ingroup io 
742 * 
743 * @tparam _CharT Type of character stream. 
744 * @tparam _Traits Traits for character type, defaults to 
745 * char_traits<_CharT>. 
746 * 
747 * This class supports reading from named files, using the inherited 
748 * functions from std::basic_ostream. To control the associated 
749 * sequence, an instance of std::basic_filebuf is used, which this page 
750 * refers to as @c sb. 
751 */ 
752 template<typename _CharT, typename _Traits> 
753 class basic_ofstream : public basic_ostream<_CharT,_Traits> 
754 { 
755 public: 
756 // Types: 
757 typedef _CharT char_type; 
758 typedef _Traits traits_type; 
759 typedef typename traits_type::int_type int_type; 
760 typedef typename traits_type::pos_type pos_type; 
761 typedef typename traits_type::off_type off_type; 
762 
763 // Non-standard types: 
764 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 
765 typedef basic_ostream<char_type, traits_type> __ostream_type; 
766 
767 private: 
768 __filebuf_type _M_filebuf; 
769 
770 public: 
771 // Constructors: 
772 /** 
773 * @brief Default constructor. 
774 * 
775 * Initializes @c sb using its default constructor, and passes 
776 * @c &sb to the base class initializer. Does not open any files 
777 * (you haven't given it a filename to open). 
778 */ 
779 basic_ofstream(): __ostream_type(), _M_filebuf() 
780 { this->init(&_M_filebuf); } 
781 
782 /** 
783 * @brief Create an output file stream. 
784 * @param __s Null terminated string specifying the filename. 
785 * @param __mode Open file in specified mode (see std::ios_base). 
786 * 
787 * @c ios_base::out is automatically included in @a __mode. 
788 */ 
789 explicit 
790 basic_ofstream(const char* __s, 
791 ios_base::openmode __mode = ios_base::out) 
792 : __ostream_type(), _M_filebuf() 
793 { 
794 this->init(&_M_filebuf); 
795 this->open(__s, __mode); 
796 } 
797 
798#if _GLIBCXX_HAVE__WFOPEN && _GLIBCXX_USE_WCHAR_T 
799 /** 
800 * @param Create an output file stream. 
801 * @param __s Wide string specifying the filename. 
802 * @param __mode Open file in specified mode (see std::ios_base). 
803 * 
804 * @c ios_base::out | @c ios_base::trunc is automatically included in 
805 * @a __mode. 
806 */ 
807 basic_ofstream(const wchar_t* __s, 
808 ios_base::openmode __mode = ios_base::out|ios_base::trunc) 
809 : __ostream_type(), _M_filebuf() 
810 { 
811 this->init(&_M_filebuf); 
812 this->open(__s, __mode); 
813 } 
814#endif 
815 
816#if __cplusplus >= 201103L 
817 /** 
818 * @brief Create an output file stream. 
819 * @param __s std::string specifying the filename. 
820 * @param __mode Open file in specified mode (see std::ios_base). 
821 * 
822 * @c ios_base::out is automatically included in @a __mode. 
823 */ 
824 explicit 
825 basic_ofstream(const std::string& __s, 
826 ios_base::openmode __mode = ios_base::out) 
827 : __ostream_type(), _M_filebuf() 
828 { 
829 this->init(&_M_filebuf); 
830 this->open(__s, __mode); 
831 } 
832 
833#if __cplusplus >= 201703L 
834 /** 
835 * @param Create an output file stream. 
836 * @param __s filesystem::path specifying the filename. 
837 * @param __mode Open file in specified mode (see std::ios_base). 
838 * 
839 * @c ios_base::out is automatically included in @a __mode. 
840 */ 
841 template<typename _Path, typename _Require = _If_fs_path<_Path>> 
842 basic_ofstream(const _Path& __s, 
843 ios_base::openmode __mode = ios_base::out) 
844 : basic_ofstream(__s.c_str(), __mode) 
845 { } 
846#endif // C++17 
847 
848 basic_ofstream(const basic_ofstream&) = delete; 
849 
850 basic_ofstream(basic_ofstream&& __rhs) 
851 : __ostream_type(std::move(__rhs)), 
852 _M_filebuf(std::move(__rhs._M_filebuf)) 
853 { __ostream_type::set_rdbuf(&_M_filebuf); } 
854#endif 
855 
856 /** 
857 * @brief The destructor does nothing. 
858 * 
859 * The file is closed by the filebuf object, not the formatting 
860 * stream. 
861 */ 
862 ~basic_ofstream() 
863 { } 
864 
865#if __cplusplus >= 201103L 
866 // 27.8.3.2 Assign and swap: 
867 
868 basic_ofstream& 
869 operator=(const basic_ofstream&) = delete; 
870 
871 basic_ofstream& 
872 operator=(basic_ofstream&& __rhs) 
873 { 
874 __ostream_type::operator=(std::move(__rhs)); 
875 _M_filebuf = std::move(__rhs._M_filebuf); 
876 return *this; 
877 } 
878 
879 void 
880 swap(basic_ofstream& __rhs) 
881 { 
882 __ostream_type::swap(__rhs); 
883 _M_filebuf.swap(__rhs._M_filebuf); 
884 } 
885#endif 
886 
887 // Members: 
888 /** 
889 * @brief Accessing the underlying buffer. 
890 * @return The current basic_filebuf buffer. 
891 * 
892 * This hides both signatures of std::basic_ios::rdbuf(). 
893 */ 
894 __filebuf_type* 
895 rdbuf() const 
896 { return const_cast<__filebuf_type*>(&_M_filebuf); } 
897 
898 /** 
899 * @brief Wrapper to test for an open file. 
900 * @return @c rdbuf()->is_open() 
901 */ 
902 bool 
903 is_open() 
904 { return _M_filebuf.is_open(); } 
905 
906 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
907 // 365. Lack of const-qualification in clause 27 
908 bool 
909 is_open() const 
910 { return _M_filebuf.is_open(); } 
911 
912 /** 
913 * @brief Opens an external file. 
914 * @param __s The name of the file. 
915 * @param __mode The open mode flags. 
916 * 
917 * Calls @c std::basic_filebuf::open(__s,__mode|out). If that 
918 * function fails, @c failbit is set in the stream's error state. 
919 */ 
920 void 
921 open(const char* __s, ios_base::openmode __mode = ios_base::out) 
922 { 
923 if (!_M_filebuf.open(__s, __mode | ios_base::out)) 
924 this->setstate(ios_base::failbit); 
925 else 
926 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
927 // 409. Closing an fstream should clear error state 
928 this->clear(); 
929 } 
930 
931#if _GLIBCXX_HAVE__WFOPEN && _GLIBCXX_USE_WCHAR_T 
932 /** 
933 * @brief Opens an external file. 
934 * @param __s The name of the file. 
935 * @param __mode The open mode flags. 
936 * 
937 * Calls @c std::basic_filebuf::open(__s,__mode|out). If that 
938 * function fails, @c failbit is set in the stream's error state. 
939 */ 
940 void 
941 open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out) 
942 { 
943 if (!_M_filebuf.open(__s, __mode | ios_base::out)) 
944 this->setstate(ios_base::failbit); 
945 else 
946 this->clear(); 
947 } 
948#endif 
949 
950#if __cplusplus >= 201103L 
951 /** 
952 * @brief Opens an external file. 
953 * @param __s The name of the file. 
954 * @param __mode The open mode flags. 
955 * 
956 * Calls @c std::basic_filebuf::open(s,mode|out). If that 
957 * function fails, @c failbit is set in the stream's error state. 
958 */ 
959 void 
960 open(const std::string& __s, ios_base::openmode __mode = ios_base::out) 
961 { 
962 if (!_M_filebuf.open(__s, __mode | ios_base::out)) 
963 this->setstate(ios_base::failbit); 
964 else 
965 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
966 // 409. Closing an fstream should clear error state 
967 this->clear(); 
968 } 
969 
970#if __cplusplus >= 201703L 
971 /** 
972 * @brief Opens an external file. 
973 * @param __s The name of the file, as a filesystem::path. 
974 * @param __mode The open mode flags. 
975 * 
976 * Calls @c std::basic_filebuf::open(__s,__mode|out). If that 
977 * function fails, @c failbit is set in the stream's error state. 
978 */ 
979 template<typename _Path> 
980 _If_fs_path<_Path, void> 
981 open(const _Path& __s, ios_base::openmode __mode = ios_base::out) 
982 { open(__s.c_str(), __mode); } 
983#endif // C++17 
984#endif // C++11 
985 
986 /** 
987 * @brief Close the file. 
988 * 
989 * Calls @c std::basic_filebuf::close(). If that function 
990 * fails, @c failbit is set in the stream's error state. 
991 */ 
992 void 
993 close() 
994 { 
995 if (!_M_filebuf.close()) 
996 this->setstate(ios_base::failbit); 
997 } 
998 }; 
999 
1000 
1001 // [27.8.1.11] Template class basic_fstream 
1002 /** 
1003 * @brief Controlling input and output for files. 
1004 * @ingroup io 
1005 * 
1006 * @tparam _CharT Type of character stream. 
1007 * @tparam _Traits Traits for character type, defaults to 
1008 * char_traits<_CharT>. 
1009 * 
1010 * This class supports reading from and writing to named files, using 
1011 * the inherited functions from std::basic_iostream. To control the 
1012 * associated sequence, an instance of std::basic_filebuf is used, which 
1013 * this page refers to as @c sb. 
1014 */ 
1015 template<typename _CharT, typename _Traits> 
1016 class basic_fstream : public basic_iostream<_CharT, _Traits> 
1017 { 
1018 public: 
1019 // Types: 
1020 typedef _CharT char_type; 
1021 typedef _Traits traits_type; 
1022 typedef typename traits_type::int_type int_type; 
1023 typedef typename traits_type::pos_type pos_type; 
1024 typedef typename traits_type::off_type off_type; 
1025 
1026 // Non-standard types: 
1027 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 
1028 typedef basic_ios<char_type, traits_type> __ios_type; 
1029 typedef basic_iostream<char_type, traits_type> __iostream_type; 
1030 
1031 private: 
1032 __filebuf_type _M_filebuf; 
1033 
1034 public: 
1035 // Constructors/destructor: 
1036 /** 
1037 * @brief Default constructor. 
1038 * 
1039 * Initializes @c sb using its default constructor, and passes 
1040 * @c &sb to the base class initializer. Does not open any files 
1041 * (you haven't given it a filename to open). 
1042 */ 
1043 basic_fstream() 
1044 : __iostream_type(), _M_filebuf() 
1045 { this->init(&_M_filebuf); } 
1046 
1047 /** 
1048 * @brief Create an input/output file stream. 
1049 * @param __s Null terminated string specifying the filename. 
1050 * @param __mode Open file in specified mode (see std::ios_base). 
1051 */ 
1052 explicit 
1053 basic_fstream(const char* __s, 
1054 ios_base::openmode __mode = ios_base::in | ios_base::out) 
1055 : __iostream_type(0), _M_filebuf() 
1056 { 
1057 this->init(&_M_filebuf); 
1058 this->open(__s, __mode); 
1059 } 
1060 
1061#if _GLIBCXX_HAVE__WFOPEN && _GLIBCXX_USE_WCHAR_T 
1062 /** 
1063 * @param Create an input/output file stream. 
1064 * @param __s Wide string specifying the filename. 
1065 * @param __mode Open file in specified mode (see std::ios_base). 
1066 */ 
1067 basic_fstream(const wchar_t* __s, 
1068 ios_base::openmode __mode = ios_base::in | ios_base::out) 
1069 : __iostream_type(0), _M_filebuf() 
1070 { 
1071 this->init(&_M_filebuf); 
1072 this->open(__s, __mode); 
1073 } 
1074#endif 
1075 
1076#if __cplusplus >= 201103L 
1077 /** 
1078 * @brief Create an input/output file stream. 
1079 * @param __s Null terminated string specifying the filename. 
1080 * @param __mode Open file in specified mode (see std::ios_base). 
1081 */ 
1082 explicit 
1083 basic_fstream(const std::string& __s, 
1084 ios_base::openmode __mode = ios_base::in | ios_base::out) 
1085 : __iostream_type(0), _M_filebuf() 
1086 { 
1087 this->init(&_M_filebuf); 
1088 this->open(__s, __mode); 
1089 } 
1090 
1091#if __cplusplus >= 201703L 
1092 /** 
1093 * @param Create an input/output file stream. 
1094 * @param __s filesystem::path specifying the filename. 
1095 * @param __mode Open file in specified mode (see std::ios_base). 
1096 */ 
1097 template<typename _Path, typename _Require = _If_fs_path<_Path>> 
1098 basic_fstream(const _Path& __s, 
1099 ios_base::openmode __mode = ios_base::in | ios_base::out) 
1100 : basic_fstream(__s.c_str(), __mode) 
1101 { } 
1102#endif // C++17 
1103 
1104 basic_fstream(const basic_fstream&) = delete; 
1105 
1106 basic_fstream(basic_fstream&& __rhs) 
1107 : __iostream_type(std::move(__rhs)), 
1108 _M_filebuf(std::move(__rhs._M_filebuf)) 
1109 { __iostream_type::set_rdbuf(&_M_filebuf); } 
1110#endif 
1111 
1112 /** 
1113 * @brief The destructor does nothing. 
1114 * 
1115 * The file is closed by the filebuf object, not the formatting 
1116 * stream. 
1117 */ 
1118 ~basic_fstream() 
1119 { } 
1120 
1121#if __cplusplus >= 201103L 
1122 // 27.8.3.2 Assign and swap: 
1123 
1124 basic_fstream& 
1125 operator=(const basic_fstream&) = delete; 
1126 
1127 basic_fstream& 
1128 operator=(basic_fstream&& __rhs) 
1129 { 
1130 __iostream_type::operator=(std::move(__rhs)); 
1131 _M_filebuf = std::move(__rhs._M_filebuf); 
1132 return *this; 
1133 } 
1134 
1135 void 
1136 swap(basic_fstream& __rhs) 
1137 { 
1138 __iostream_type::swap(__rhs); 
1139 _M_filebuf.swap(__rhs._M_filebuf); 
1140 } 
1141#endif 
1142 
1143 // Members: 
1144 /** 
1145 * @brief Accessing the underlying buffer. 
1146 * @return The current basic_filebuf buffer. 
1147 * 
1148 * This hides both signatures of std::basic_ios::rdbuf(). 
1149 */ 
1150 __filebuf_type* 
1151 rdbuf() const 
1152 { return const_cast<__filebuf_type*>(&_M_filebuf); } 
1153 
1154 /** 
1155 * @brief Wrapper to test for an open file. 
1156 * @return @c rdbuf()->is_open() 
1157 */ 
1158 bool 
1159 is_open() 
1160 { return _M_filebuf.is_open(); } 
1161 
1162 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
1163 // 365. Lack of const-qualification in clause 27 
1164 bool 
1165 is_open() const 
1166 { return _M_filebuf.is_open(); } 
1167 
1168 /** 
1169 * @brief Opens an external file. 
1170 * @param __s The name of the file. 
1171 * @param __mode The open mode flags. 
1172 * 
1173 * Calls @c std::basic_filebuf::open(__s,__mode). If that 
1174 * function fails, @c failbit is set in the stream's error state. 
1175 */ 
1176 void 
1177 open(const char* __s, 
1178 ios_base::openmode __mode = ios_base::in | ios_base::out) 
1179 { 
1180 if (!_M_filebuf.open(__s, __mode)) 
1181 this->setstate(ios_base::failbit); 
1182 else 
1183 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
1184 // 409. Closing an fstream should clear error state 
1185 this->clear(); 
1186 } 
1187 
1188#if _GLIBCXX_HAVE__WFOPEN && _GLIBCXX_USE_WCHAR_T 
1189 /** 
1190 * @brief Opens an external file. 
1191 * @param __s The name of the file. 
1192 * @param __mode The open mode flags. 
1193 * 
1194 * Calls @c std::basic_filebuf::open(__s,__mode). If that 
1195 * function fails, @c failbit is set in the stream's error state. 
1196 */ 
1197 void 
1198 open(const wchar_t* __s, 
1199 ios_base::openmode __mode = ios_base::in | ios_base::out) 
1200 { 
1201 if (!_M_filebuf.open(__s, __mode)) 
1202 this->setstate(ios_base::failbit); 
1203 else 
1204 this->clear(); 
1205 } 
1206#endif 
1207 
1208#if __cplusplus >= 201103L 
1209 /** 
1210 * @brief Opens an external file. 
1211 * @param __s The name of the file. 
1212 * @param __mode The open mode flags. 
1213 * 
1214 * Calls @c std::basic_filebuf::open(__s,__mode). If that 
1215 * function fails, @c failbit is set in the stream's error state. 
1216 */ 
1217 void 
1218 open(const std::string& __s, 
1219 ios_base::openmode __mode = ios_base::in | ios_base::out) 
1220 { 
1221 if (!_M_filebuf.open(__s, __mode)) 
1222 this->setstate(ios_base::failbit); 
1223 else 
1224 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
1225 // 409. Closing an fstream should clear error state 
1226 this->clear(); 
1227 } 
1228 
1229#if __cplusplus >= 201703L 
1230 /** 
1231 * @brief Opens an external file. 
1232 * @param __s The name of the file, as a filesystem::path. 
1233 * @param __mode The open mode flags. 
1234 * 
1235 * Calls @c std::basic_filebuf::open(__s,__mode). If that 
1236 * function fails, @c failbit is set in the stream's error state. 
1237 */ 
1238 template<typename _Path> 
1239 _If_fs_path<_Path, void> 
1240 open(const _Path& __s, 
1241 ios_base::openmode __mode = ios_base::in | ios_base::out) 
1242 { open(__s.c_str(), __mode); } 
1243#endif // C++17 
1244#endif // C++11 
1245 
1246 /** 
1247 * @brief Close the file. 
1248 * 
1249 * Calls @c std::basic_filebuf::close(). If that function 
1250 * fails, @c failbit is set in the stream's error state. 
1251 */ 
1252 void 
1253 close() 
1254 { 
1255 if (!_M_filebuf.close()) 
1256 this->setstate(ios_base::failbit); 
1257 } 
1258 }; 
1259 
1260#if __cplusplus >= 201103L 
1261 /// Swap specialization for filebufs. 
1262 template <class _CharT, class _Traits> 
1263 inline void 
1264 swap(basic_filebuf<_CharT, _Traits>& __x, 
1265 basic_filebuf<_CharT, _Traits>& __y) 
1266 { __x.swap(__y); } 
1267 
1268 /// Swap specialization for ifstreams. 
1269 template <class _CharT, class _Traits> 
1270 inline void 
1271 swap(basic_ifstream<_CharT, _Traits>& __x, 
1272 basic_ifstream<_CharT, _Traits>& __y) 
1273 { __x.swap(__y); } 
1274 
1275 /// Swap specialization for ofstreams. 
1276 template <class _CharT, class _Traits> 
1277 inline void 
1278 swap(basic_ofstream<_CharT, _Traits>& __x, 
1279 basic_ofstream<_CharT, _Traits>& __y) 
1280 { __x.swap(__y); } 
1281 
1282 /// Swap specialization for fstreams. 
1283 template <class _CharT, class _Traits> 
1284 inline void 
1285 swap(basic_fstream<_CharT, _Traits>& __x, 
1286 basic_fstream<_CharT, _Traits>& __y) 
1287 { __x.swap(__y); } 
1288#endif 
1289 
1290_GLIBCXX_END_NAMESPACE_VERSION 
1291} // namespace 
1292 
1293#include <bits/fstream.tcc> 
1294 
1295#endif /* _GLIBCXX_FSTREAM */ 
1296