libstdc++
istream
Go to the documentation of this file.
1 // Input streams -*- C++ -*-
2 
3 // Copyright (C) 1997-2025 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 //
26 // ISO C++ 14882: 27.6.1 Input streams
27 //
28 
29 /** @file include/istream
30  * This is a Standard C++ Library header.
31  */
32 
33 #ifndef _GLIBCXX_ISTREAM
34 #define _GLIBCXX_ISTREAM 1
35 
36 #ifdef _GLIBCXX_SYSHDR
37 #pragma GCC system_header
38 #endif
39 
40 #include <bits/requires_hosted.h> // iostreams
41 
42 #include <ios>
43 #include <ostream>
44 
45 namespace std _GLIBCXX_VISIBILITY(default)
46 {
47 _GLIBCXX_BEGIN_NAMESPACE_VERSION
48 
49  /**
50  * @brief Template class basic_istream.
51  * @ingroup io
52  *
53  * @tparam _CharT Type of character stream.
54  * @tparam _Traits Traits for character type, defaults to
55  * char_traits<_CharT>.
56  *
57  * This is the base class for all input streams. It provides text
58  * formatting of all builtin types, and communicates with any class
59  * derived from basic_streambuf to do the actual input.
60  */
61  template<typename _CharT, typename _Traits>
62  class basic_istream : virtual public basic_ios<_CharT, _Traits>
63  {
64  public:
65  // Types (inherited from basic_ios (27.4.4)):
66  typedef _CharT char_type;
67  typedef typename _Traits::int_type int_type;
68  typedef typename _Traits::pos_type pos_type;
69  typedef typename _Traits::off_type off_type;
70  typedef _Traits traits_type;
71 
72  // Non-standard Types:
73  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
74  typedef basic_ios<_CharT, _Traits> __ios_type;
75  typedef basic_istream<_CharT, _Traits> __istream_type;
76  typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
77  __num_get_type;
78  typedef ctype<_CharT> __ctype_type;
79 
80  protected:
81  // Data Members:
82  /**
83  * The number of characters extracted in the previous unformatted
84  * function; see gcount().
85  */
86  streamsize _M_gcount;
87 
88  public:
89  /**
90  * @brief Base constructor.
91  *
92  * This ctor is almost never called by the user directly, rather from
93  * derived classes' initialization lists, which pass a pointer to
94  * their own stream buffer.
95  */
96  explicit
97  basic_istream(__streambuf_type* __sb)
98  : _M_gcount(streamsize(0))
99  { this->init(__sb); }
100 
101  /**
102  * @brief Base destructor.
103  *
104  * This does very little apart from providing a virtual base dtor.
105  */
106  virtual
107  ~basic_istream()
108  { _M_gcount = streamsize(0); }
109 
110  /// Safe prefix/suffix operations.
111  class sentry;
112  friend class sentry;
113 
114  ///@{
115  /**
116  * @brief Interface for manipulators.
117  *
118  * Manipulators such as @c std::ws and @c std::dec use these
119  * functions in constructs like
120  * <code>std::cin >> std::ws</code>.
121  * For more information, see the iomanip header.
122  */
123  __istream_type&
124  operator>>(__istream_type& (*__pf)(__istream_type&))
125  { return __pf(*this); }
126 
127  __istream_type&
128  operator>>(__ios_type& (*__pf)(__ios_type&))
129  {
130  __pf(*this);
131  return *this;
132  }
133 
134  __istream_type&
135  operator>>(ios_base& (*__pf)(ios_base&))
136  {
137  __pf(*this);
138  return *this;
139  }
140  ///@}
141 
142  ///@{
143  /**
144  * @name Extractors
145  *
146  * All the @c operator>> functions (aka <em>formatted input
147  * functions</em>) have some common behavior. Each starts by
148  * constructing a temporary object of type std::basic_istream::sentry
149  * with the second argument (noskipws) set to false. This has several
150  * effects, concluding with the setting of a status flag; see the
151  * sentry documentation for more.
152  *
153  * If the sentry status is good, the function tries to extract
154  * whatever data is appropriate for the type of the argument.
155  *
156  * If an exception is thrown during extraction, ios_base::badbit
157  * will be turned on in the stream's error state (without causing an
158  * ios_base::failure to be thrown) and the original exception will
159  * be rethrown if badbit is set in the exceptions mask.
160  */
161 
162  ///@{
163  /**
164  * @brief Integer arithmetic extractors
165  * @param __n A variable of builtin integral type.
166  * @return @c *this if successful
167  *
168  * These functions use the stream's current locale (specifically, the
169  * @c num_get facet) to parse the input data.
170  */
171  __istream_type&
172  operator>>(bool& __n)
173  { return _M_extract(__n); }
174 
175  __istream_type&
176  operator>>(short& __n);
177 
178  __istream_type&
179  operator>>(unsigned short& __n)
180  { return _M_extract(__n); }
181 
182  __istream_type&
183  operator>>(int& __n);
184 
185  __istream_type&
186  operator>>(unsigned int& __n)
187  { return _M_extract(__n); }
188 
189  __istream_type&
190  operator>>(long& __n)
191  { return _M_extract(__n); }
192 
193  __istream_type&
194  operator>>(unsigned long& __n)
195  { return _M_extract(__n); }
196 
197 #ifdef _GLIBCXX_USE_LONG_LONG
198 #pragma GCC diagnostic push
199 #pragma GCC diagnostic ignored "-Wlong-long"
200  __istream_type&
201  operator>>(long long& __n)
202  { return _M_extract(__n); }
203 
204  __istream_type&
205  operator>>(unsigned long long& __n)
206  { return _M_extract(__n); }
207 #pragma GCC diagnostic pop
208 #endif
209  ///@}
210 
211  ///@{
212  /**
213  * @brief Floating point arithmetic extractors
214  * @param __f A variable of builtin floating point type.
215  * @return @c *this if successful
216  *
217  * These functions use the stream's current locale (specifically, the
218  * @c num_get facet) to parse the input data.
219  */
220  __istream_type&
221  operator>>(float& __f)
222  { return _M_extract(__f); }
223 
224  __istream_type&
225  operator>>(double& __f)
226  { return _M_extract(__f); }
227 
228  __istream_type&
229  operator>>(long double& __f)
230  { return _M_extract(__f); }
231  ///@}
232 
233 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
234  __attribute__((__always_inline__))
235  __istream_type&
236  operator>>(_Float16& __f)
237  {
238  float __flt;
239  __istream_type& __ret = _M_extract(__flt);
240  ios_base::iostate __err = ios_base::goodbit;
241  if (__flt < -__FLT16_MAX__)
242  {
243  __f = -__FLT16_MAX__;
244  __err = ios_base::failbit;
245  }
246  else if (__flt > __FLT16_MAX__)
247  {
248  __f = __FLT16_MAX__;
249  __err = ios_base::failbit;
250  }
251  else
252  __f = static_cast<_Float16>(__flt);
253  if (__err)
254  this->setstate(__err);
255  return __ret;
256  }
257 #endif
258 
259 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
260  __attribute__((__always_inline__))
261  __istream_type&
262  operator>>(_Float32& __f)
263  {
264  float __flt;
265  __istream_type& __ret = _M_extract(__flt);
266  __f = static_cast<_Float32> (__flt);
267  return __ret;
268  }
269 #endif
270 
271 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
272  __attribute__((__always_inline__))
273  __istream_type&
274  operator>>(_Float64& __f)
275  {
276  double __dbl;
277  __istream_type& __ret = _M_extract(__dbl);
278  __f = static_cast<_Float64> (__dbl);
279  return __ret;
280  }
281 #endif
282 
283 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
284  __attribute__((__always_inline__))
285  __istream_type&
286  operator>>(_Float128& __f)
287  {
288  long double __ldbl;
289  __istream_type& __ret = _M_extract(__ldbl);
290  __f = static_cast<_Float128> (__ldbl);
291  return __ret;
292  }
293 #endif
294 
295 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
296  __attribute__((__always_inline__))
297  __istream_type&
298  operator>>(__gnu_cxx::__bfloat16_t & __f)
299  {
300  float __flt;
301  __istream_type& __ret = _M_extract(__flt);
302  ios_base::iostate __err = ios_base::goodbit;
303  if (__flt < -__BFLT16_MAX__)
304  {
305  __f = -__BFLT16_MAX__;
306  __err = ios_base::failbit;
307  }
308  else if (__flt > __BFLT16_MAX__)
309  {
310  __f = __BFLT16_MAX__;
311  __err = ios_base::failbit;
312  }
313  else
314  __f = static_cast<__gnu_cxx::__bfloat16_t>(__flt);
315  if (__err)
316  this->setstate(__err);
317  return __ret;
318  }
319 #endif
320 
321  /**
322  * @brief Basic arithmetic extractors
323  * @param __p A variable of pointer type.
324  * @return @c *this if successful
325  *
326  * These functions use the stream's current locale (specifically, the
327  * @c num_get facet) to parse the input data.
328  */
329  __istream_type&
330  operator>>(void*& __p)
331  { return _M_extract(__p); }
332 
333  /**
334  * @brief Extracting into another streambuf.
335  * @param __sb A pointer to a streambuf
336  *
337  * This function behaves like one of the basic arithmetic extractors,
338  * in that it also constructs a sentry object and has the same error
339  * handling behavior.
340  *
341  * If @p __sb is NULL, the stream will set failbit in its error state.
342  *
343  * Characters are extracted from this stream and inserted into the
344  * @p __sb streambuf until one of the following occurs:
345  *
346  * - the input stream reaches end-of-file,
347  * - insertion into the output buffer fails (in this case, the
348  * character that would have been inserted is not extracted), or
349  * - an exception occurs (and in this case is caught)
350  *
351  * If the function inserts no characters, failbit is set.
352  */
353  __istream_type&
354  operator>>(__streambuf_type* __sb);
355  ///@}
356 
357  // [27.6.1.3] unformatted input
358  /**
359  * @brief Character counting
360  * @return The number of characters extracted by the previous
361  * unformatted input function dispatched for this stream.
362  */
363  streamsize
364  gcount() const
365  { return _M_gcount; }
366 
367  ///@{
368  /**
369  * @name Unformatted Input Functions
370  *
371  * All the unformatted input functions have some common behavior.
372  * Each starts by constructing a temporary object of type
373  * std::basic_istream::sentry with the second argument (noskipws)
374  * set to true. This has several effects, concluding with the
375  * setting of a status flag; see the sentry documentation for more.
376  *
377  * If the sentry status is good, the function tries to extract
378  * whatever data is appropriate for the type of the argument.
379  *
380  * The number of characters extracted is stored for later retrieval
381  * by gcount().
382  *
383  * If an exception is thrown during extraction, ios_base::badbit
384  * will be turned on in the stream's error state (without causing an
385  * ios_base::failure to be thrown) and the original exception will
386  * be rethrown if badbit is set in the exceptions mask.
387  */
388 
389  /**
390  * @brief Simple extraction.
391  * @return A character, or eof().
392  *
393  * Tries to extract a character. If none are available, sets failbit
394  * and returns traits::eof().
395  */
396  int_type
397  get();
398 
399  /**
400  * @brief Simple extraction.
401  * @param __c The character in which to store data.
402  * @return *this
403  *
404  * Tries to extract a character and store it in @a __c. If none are
405  * available, sets failbit and returns traits::eof().
406  *
407  * @note This function is not overloaded on signed char and
408  * unsigned char.
409  */
410  __istream_type&
411  get(char_type& __c);
412 
413  /**
414  * @brief Simple multiple-character extraction.
415  * @param __s Pointer to an array.
416  * @param __n Maximum number of characters to store in @a __s.
417  * @param __delim A "stop" character.
418  * @return *this
419  *
420  * Characters are extracted and stored into @a __s until one of the
421  * following happens:
422  *
423  * - @c __n-1 characters are stored
424  * - the input sequence reaches EOF
425  * - the next character equals @a __delim, in which case the character
426  * is not extracted
427  *
428  * If no characters are stored, failbit is set in the stream's error
429  * state.
430  *
431  * In any case, a null character is stored into the next location in
432  * the array.
433  *
434  * @note This function is not overloaded on signed char and
435  * unsigned char.
436  */
437  __istream_type&
438  get(char_type* __s, streamsize __n, char_type __delim);
439 
440  /**
441  * @brief Simple multiple-character extraction.
442  * @param __s Pointer to an array.
443  * @param __n Maximum number of characters to store in @a s.
444  * @return *this
445  *
446  * Returns @c get(__s,__n,widen(&apos;\\n&apos;)).
447  */
448  __istream_type&
449  get(char_type* __s, streamsize __n)
450  { return this->get(__s, __n, this->widen('\n')); }
451 
452  /**
453  * @brief Extraction into another streambuf.
454  * @param __sb A streambuf in which to store data.
455  * @param __delim A "stop" character.
456  * @return *this
457  *
458  * Characters are extracted and inserted into @a __sb until one of the
459  * following happens:
460  *
461  * - the input sequence reaches EOF
462  * - insertion into the output buffer fails (in this case, the
463  * character that would have been inserted is not extracted)
464  * - the next character equals @a __delim (in this case, the character
465  * is not extracted)
466  * - an exception occurs (and in this case is caught)
467  *
468  * If no characters are stored, failbit is set in the stream's error
469  * state.
470  */
471  __istream_type&
472  get(__streambuf_type& __sb, char_type __delim);
473 
474  /**
475  * @brief Extraction into another streambuf.
476  * @param __sb A streambuf in which to store data.
477  * @return *this
478  *
479  * Returns @c get(__sb,widen(&apos;\\n&apos;)).
480  */
481  __istream_type&
482  get(__streambuf_type& __sb)
483  { return this->get(__sb, this->widen('\n')); }
484 
485  /**
486  * @brief String extraction.
487  * @param __s A character array in which to store the data.
488  * @param __n Maximum number of characters to extract.
489  * @param __delim A "stop" character.
490  * @return *this
491  *
492  * Extracts and stores characters into @a __s until one of the
493  * following happens. Note that these criteria are required to be
494  * tested in the order listed here, to allow an input line to exactly
495  * fill the @a __s array without setting failbit.
496  *
497  * -# the input sequence reaches end-of-file, in which case eofbit
498  * is set in the stream error state
499  * -# the next character equals @c __delim, in which case the character
500  * is extracted (and therefore counted in @c gcount()) but not stored
501  * -# @c __n-1 characters are stored, in which case failbit is set
502  * in the stream error state
503  *
504  * If no characters are extracted, failbit is set. (An empty line of
505  * input should therefore not cause failbit to be set.)
506  *
507  * In any case, a null character is stored in the next location in
508  * the array.
509  */
510  __istream_type&
511  getline(char_type* __s, streamsize __n, char_type __delim);
512 
513  /**
514  * @brief String extraction.
515  * @param __s A character array in which to store the data.
516  * @param __n Maximum number of characters to extract.
517  * @return *this
518  *
519  * Returns @c getline(__s,__n,widen(&apos;\\n&apos;)).
520  */
521  __istream_type&
522  getline(char_type* __s, streamsize __n)
523  { return this->getline(__s, __n, this->widen('\n')); }
524 
525  /**
526  * @brief Discarding characters
527  * @param __n Number of characters to discard.
528  * @param __delim A "stop" character.
529  * @return *this
530  *
531  * Extracts characters and throws them away until one of the
532  * following happens:
533  * - if @a __n @c != @c std::numeric_limits<int>::max(), @a __n
534  * characters are extracted
535  * - the input sequence reaches end-of-file
536  * - the next character equals @a __delim (in this case, the character
537  * is extracted); note that this condition will never occur if
538  * @a __delim equals @c traits::eof().
539  *
540  * NB: Provide three overloads, instead of the single function
541  * (with defaults) mandated by the Standard: this leads to a
542  * better performing implementation, while still conforming to
543  * the Standard.
544  */
545  __istream_type&
546  ignore(streamsize __n, int_type __delim);
547 
548  __istream_type&
549  ignore(streamsize __n);
550 
551  __istream_type&
552  ignore();
553 
554  /**
555  * @brief Looking ahead in the stream
556  * @return The next character, or eof().
557  *
558  * If, after constructing the sentry object, @c good() is false,
559  * returns @c traits::eof(). Otherwise reads but does not extract
560  * the next input character.
561  */
562  int_type
563  peek();
564 
565  /**
566  * @brief Extraction without delimiters.
567  * @param __s A character array.
568  * @param __n Maximum number of characters to store.
569  * @return *this
570  *
571  * If the stream state is @c good(), extracts characters and stores
572  * them into @a __s until one of the following happens:
573  * - @a __n characters are stored
574  * - the input sequence reaches end-of-file, in which case the error
575  * state is set to @c failbit|eofbit.
576  *
577  * @note This function is not overloaded on signed char and
578  * unsigned char.
579  */
580  __istream_type&
581  read(char_type* __s, streamsize __n);
582 
583  /**
584  * @brief Extraction until the buffer is exhausted, but no more.
585  * @param __s A character array.
586  * @param __n Maximum number of characters to store.
587  * @return The number of characters extracted.
588  *
589  * Extracts characters and stores them into @a __s depending on the
590  * number of characters remaining in the streambuf's buffer,
591  * @c rdbuf()->in_avail(), called @c A here:
592  * - if @c A @c == @c -1, sets eofbit and extracts no characters
593  * - if @c A @c == @c 0, extracts no characters
594  * - if @c A @c > @c 0, extracts @c min(A,n)
595  *
596  * The goal is to empty the current buffer, and to not request any
597  * more from the external input sequence controlled by the streambuf.
598  */
599  streamsize
600  readsome(char_type* __s, streamsize __n);
601 
602  /**
603  * @brief Unextracting a single character.
604  * @param __c The character to push back into the input stream.
605  * @return *this
606  *
607  * If @c rdbuf() is not null, calls @c rdbuf()->sputbackc(c).
608  *
609  * If @c rdbuf() is null or if @c sputbackc() fails, sets badbit in
610  * the error state.
611  *
612  * @note This function first clears eofbit. Since no characters
613  * are extracted, the next call to @c gcount() will return 0,
614  * as required by DR 60.
615  */
616  __istream_type&
617  putback(char_type __c);
618 
619  /**
620  * @brief Unextracting the previous character.
621  * @return *this
622  *
623  * If @c rdbuf() is not null, calls @c rdbuf()->sungetc(c).
624  *
625  * If @c rdbuf() is null or if @c sungetc() fails, sets badbit in
626  * the error state.
627  *
628  * @note This function first clears eofbit. Since no characters
629  * are extracted, the next call to @c gcount() will return 0,
630  * as required by DR 60.
631  */
632  __istream_type&
633  unget();
634 
635  /**
636  * @brief Synchronizing the stream buffer.
637  * @return 0 on success, -1 on failure
638  *
639  * If @c rdbuf() is a null pointer, returns -1.
640  *
641  * Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
642  * sets badbit and returns -1.
643  *
644  * Otherwise, returns 0.
645  *
646  * @note This function does not count the number of characters
647  * extracted, if any, and therefore does not affect the next
648  * call to @c gcount().
649  */
650  int
651  sync();
652 
653  /**
654  * @brief Getting the current read position.
655  * @return A file position object.
656  *
657  * If @c fail() is not false, returns @c pos_type(-1) to indicate
658  * failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,in).
659  *
660  * @note This function does not count the number of characters
661  * extracted, if any, and therefore does not affect the next
662  * call to @c gcount(). At variance with putback, unget and
663  * seekg, eofbit is not cleared first.
664  */
665  pos_type
666  tellg();
667 
668  /**
669  * @brief Changing the current read position.
670  * @param __pos A file position object.
671  * @return *this
672  *
673  * If @c fail() is not true, calls @c rdbuf()->pubseekpos(__pos). If
674  * that function fails, sets failbit.
675  *
676  * @note This function first clears eofbit. It does not count the
677  * number of characters extracted, if any, and therefore does
678  * not affect the next call to @c gcount().
679  */
680  __istream_type&
681  seekg(pos_type);
682 
683  /**
684  * @brief Changing the current read position.
685  * @param __off A file offset object.
686  * @param __dir The direction in which to seek.
687  * @return *this
688  *
689  * If @c fail() is not true, calls @c rdbuf()->pubseekoff(__off,__dir).
690  * If that function fails, sets failbit.
691  *
692  * @note This function first clears eofbit. It does not count the
693  * number of characters extracted, if any, and therefore does
694  * not affect the next call to @c gcount().
695  */
696  __istream_type&
697  seekg(off_type, ios_base::seekdir);
698  ///@}
699 
700  protected:
701  basic_istream()
702  : _M_gcount(streamsize(0))
703  { this->init(0); }
704 
705 #if __cplusplus >= 201103L
706  basic_istream(const basic_istream&) = delete;
707 
708  basic_istream(basic_istream&& __rhs)
709  : __ios_type(), _M_gcount(__rhs._M_gcount)
710  {
711  __ios_type::move(__rhs);
712  __rhs._M_gcount = 0;
713  }
714 
715  // 27.7.3.3 Assign/swap
716 
717  basic_istream& operator=(const basic_istream&) = delete;
718 
719  basic_istream&
720  operator=(basic_istream&& __rhs)
721  {
722  swap(__rhs);
723  return *this;
724  }
725 
726  void
727  swap(basic_istream& __rhs)
728  {
729  __ios_type::swap(__rhs);
730  std::swap(_M_gcount, __rhs._M_gcount);
731  }
732 #endif
733 
734  template<typename _ValueT>
735  __istream_type&
736  _M_extract(_ValueT& __v);
737  };
738 
739  /// Explicit specialization declarations, defined in src/istream.cc.
740  template<>
741  basic_istream<char>&
742  basic_istream<char>::
743  getline(char_type* __s, streamsize __n, char_type __delim);
744 
745  template<>
746  basic_istream<char>&
747  basic_istream<char>::
748  ignore(streamsize __n);
749 
750  template<>
751  basic_istream<char>&
752  basic_istream<char>::
753  ignore(streamsize __n, int_type __delim);
754 
755 #ifdef _GLIBCXX_USE_WCHAR_T
756  template<>
757  basic_istream<wchar_t>&
758  basic_istream<wchar_t>::
759  getline(char_type* __s, streamsize __n, char_type __delim);
760 
761  template<>
762  basic_istream<wchar_t>&
763  basic_istream<wchar_t>::
764  ignore(streamsize __n);
765 
766  template<>
767  basic_istream<wchar_t>&
768  basic_istream<wchar_t>::
769  ignore(streamsize __n, int_type __delim);
770 #endif
771 
772  /**
773  * @brief Performs setup work for input streams.
774  *
775  * Objects of this class are created before all of the standard
776  * extractors are run. It is responsible for <em>exception-safe
777  * prefix and suffix operations,</em> although only prefix actions
778  * are currently required by the standard.
779  */
780  template<typename _CharT, typename _Traits>
781  class basic_istream<_CharT, _Traits>::sentry
782  {
783  // Data Members.
784  bool _M_ok;
785 
786  public:
787  /// Easy access to dependent types.
788  typedef _Traits traits_type;
789  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
790  typedef basic_istream<_CharT, _Traits> __istream_type;
791  typedef typename __istream_type::__ctype_type __ctype_type;
792  typedef typename _Traits::int_type __int_type;
793 
794  /**
795  * @brief The constructor performs all the work.
796  * @param __is The input stream to guard.
797  * @param __noskipws Whether to consume whitespace or not.
798  *
799  * If the stream state is good (@a __is.good() is true), then the
800  * following actions are performed, otherwise the sentry state
801  * is false (<em>not okay</em>) and failbit is set in the
802  * stream state.
803  *
804  * The sentry's preparatory actions are:
805  *
806  * -# if the stream is tied to an output stream, @c is.tie()->flush()
807  * is called to synchronize the output sequence
808  * -# if @a __noskipws is false, and @c ios_base::skipws is set in
809  * @c is.flags(), the sentry extracts and discards whitespace
810  * characters from the stream. The currently imbued locale is
811  * used to determine whether each character is whitespace.
812  *
813  * If the stream state is still good, then the sentry state becomes
814  * true (@a okay).
815  */
816  explicit
817  sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
818 
819  /**
820  * @brief Quick status checking.
821  * @return The sentry state.
822  *
823  * For ease of use, sentries may be converted to booleans. The
824  * return value is that of the sentry state (true == okay).
825  */
826 #if __cplusplus >= 201103L
827  explicit
828 #endif
829  operator bool() const
830  { return _M_ok; }
831  };
832 
833  ///@{
834  /**
835  * @brief Character extractors
836  * @param __in An input stream.
837  * @param __c A character reference.
838  * @return in
839  *
840  * Behaves like one of the formatted arithmetic extractors described in
841  * std::basic_istream. After constructing a sentry object with good
842  * status, this function extracts a character (if one is available) and
843  * stores it in @a __c. Otherwise, sets failbit in the input stream.
844  */
845  template<typename _CharT, typename _Traits>
846  basic_istream<_CharT, _Traits>&
847  operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
848 
849  template<class _Traits>
850  inline basic_istream<char, _Traits>&
851  operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
852  { return (__in >> reinterpret_cast<char&>(__c)); }
853 
854  template<class _Traits>
855  inline basic_istream<char, _Traits>&
856  operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
857  { return (__in >> reinterpret_cast<char&>(__c)); }
858  ///@}
859 
860 
861  template<typename _CharT, typename _Traits>
862  void
863  __istream_extract(basic_istream<_CharT, _Traits>&, _CharT*, streamsize);
864 
865  void __istream_extract(istream&, char*, streamsize);
866 
867  ///@{
868  /**
869  * @brief Character string extractors
870  * @param __in An input stream.
871  * @param __s A character array (or a pointer to an array before C++20).
872  * @return __in
873  *
874  * Behaves like one of the formatted arithmetic extractors described in
875  * `std::basic_istream`. After constructing a sentry object with good
876  * status, this function extracts up to `n` characters and stores them
877  * into the array `__s`. `n` is defined as:
878  *
879  * - if `width()` is greater than zero, `n` is `min(width(), n)`
880  * - otherwise `n` is the number of elements of the array
881  * - (before C++20 the pointer is assumed to point to an array of
882  * the largest possible size for an array of `char_type`).
883  *
884  * Characters are extracted and stored until one of the following happens:
885  * - `n - 1` characters are stored
886  * - EOF is reached
887  * - the next character is whitespace according to the current locale
888  *
889  * `width(0)` is then called for the input stream.
890  *
891  * If no characters are extracted, sets failbit.
892  */
893 
894 #if __cplusplus <= 201703L
895  template<typename _CharT, typename _Traits>
896  __attribute__((__nonnull__(2), __access__(__write_only__, 2)))
897  inline basic_istream<_CharT, _Traits>&
898  operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
899  {
900 #ifdef __OPTIMIZE__
901  // Function inlining might make the buffer size known, allowing us to
902  // prevent overflow.
903  size_t __n = __builtin_object_size(__s, 0);
904  if (__n < sizeof(_CharT))
905  {
906  // There is not even space for the required null terminator.
907  __glibcxx_assert(__n >= sizeof(_CharT));
908  // No point calling __istream_extract, but still need to reset width.
909  __in.width(0);
910  __in.setstate(ios_base::failbit);
911  }
912  else if (__n != (size_t)-1)
913  {
914  __n /= sizeof(_CharT);
915  streamsize __w = __in.width();
916  std::__istream_extract(__in, __s, __n);
917  if (__in.good() && (__w <= 0 || __n < (size_t)__w))
918  {
919  // Stopped extracting early to avoid overflowing the buffer,
920  // but might have stopped anyway (and set eofbit) if at EOF.
921  const typename _Traits::int_type __c = __in.rdbuf()->sgetc();
922  const bool __eof = _Traits::eq_int_type(__c, _Traits::eof());
923  if (__builtin_expect(__eof, true)) // Assume EOF, not overflow.
924  __in.setstate(ios_base::eofbit);
925  }
926  }
927  else
928 #endif // __OPTIMIZE
929  {
930  // Buffer size is unknown, have to assume it's huge.
931  streamsize __n = __gnu_cxx::__numeric_traits<streamsize>::__max;
932  __n /= sizeof(_CharT);
933  std::__istream_extract(__in, __s, __n);
934  }
935  return __in;
936  }
937 
938  template<class _Traits>
939  __attribute__((__nonnull__(2), __access__(__write_only__, 2)))
940  inline basic_istream<char, _Traits>&
941  operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
942  { return __in >> reinterpret_cast<char*>(__s); }
943 
944  template<class _Traits>
945  __attribute__((__nonnull__(2), __access__(__write_only__, 2)))
946  inline basic_istream<char, _Traits>&
947  operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
948  { return __in >> reinterpret_cast<char*>(__s); }
949 #else
950  // _GLIBCXX_RESOLVE_LIB_DEFECTS
951  // 2499. operator>>(istream&, char*) makes it hard to avoid buffer overflows
952  template<typename _CharT, typename _Traits, size_t _Num>
953  inline basic_istream<_CharT, _Traits>&
954  operator>>(basic_istream<_CharT, _Traits>& __in, _CharT (&__s)[_Num])
955  {
956  static_assert(_Num <= __gnu_cxx::__numeric_traits<streamsize>::__max);
957  std::__istream_extract(__in, __s, _Num);
958  return __in;
959  }
960 
961  template<class _Traits, size_t _Num>
962  inline basic_istream<char, _Traits>&
963  operator>>(basic_istream<char, _Traits>& __in, unsigned char (&__s)[_Num])
964  { return __in >> reinterpret_cast<char(&)[_Num]>(__s); }
965 
966  template<class _Traits, size_t _Num>
967  inline basic_istream<char, _Traits>&
968  operator>>(basic_istream<char, _Traits>& __in, signed char (&__s)[_Num])
969  { return __in >> reinterpret_cast<char(&)[_Num]>(__s); }
970 #endif
971  ///@}
972 
973  /**
974  * @brief Template class basic_iostream
975  * @ingroup io
976  *
977  * @tparam _CharT Type of character stream.
978  * @tparam _Traits Traits for character type, defaults to
979  * char_traits<_CharT>.
980  *
981  * This class multiply inherits from the input and output stream classes
982  * simply to provide a single interface.
983  */
984  template<typename _CharT, typename _Traits>
985  class basic_iostream
986  : public basic_istream<_CharT, _Traits>,
987  public basic_ostream<_CharT, _Traits>
988  {
989  public:
990  // _GLIBCXX_RESOLVE_LIB_DEFECTS
991  // 271. basic_iostream missing typedefs
992  // Types (inherited):
993  typedef _CharT char_type;
994  typedef typename _Traits::int_type int_type;
995  typedef typename _Traits::pos_type pos_type;
996  typedef typename _Traits::off_type off_type;
997  typedef _Traits traits_type;
998 
999  // Non-standard Types:
1000  typedef basic_istream<_CharT, _Traits> __istream_type;
1001  typedef basic_ostream<_CharT, _Traits> __ostream_type;
1002 
1003  /**
1004  * @brief Constructor does nothing.
1005  *
1006  * Both of the parent classes are initialized with the same
1007  * streambuf pointer passed to this constructor.
1008  */
1009  explicit
1010  basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
1011  : __istream_type(__sb), __ostream_type(__sb) { }
1012 
1013  /**
1014  * @brief Destructor does nothing.
1015  */
1016  virtual
1017  ~basic_iostream() { }
1018 
1019  protected:
1020  basic_iostream()
1021  : __istream_type(), __ostream_type() { }
1022 
1023 #if __cplusplus >= 201103L
1024  basic_iostream(const basic_iostream&) = delete;
1025 
1026  basic_iostream(basic_iostream&& __rhs)
1027  : __istream_type(std::move(__rhs)), __ostream_type(*this)
1028  { }
1029 
1030  // 27.7.3.3 Assign/swap
1031 
1032  basic_iostream& operator=(const basic_iostream&) = delete;
1033 
1034  basic_iostream&
1035  operator=(basic_iostream&& __rhs)
1036  {
1037  swap(__rhs);
1038  return *this;
1039  }
1040 
1041  void
1042  swap(basic_iostream& __rhs)
1043  { __istream_type::swap(__rhs); }
1044 #endif
1045  };
1046 
1047  /**
1048  * @brief Quick and easy way to eat whitespace
1049  *
1050  * This manipulator extracts whitespace characters, stopping when the
1051  * next character is non-whitespace, or when the input sequence is empty.
1052  * If the sequence is empty, @c eofbit is set in the stream, but not
1053  * @c failbit.
1054  *
1055  * The current locale is used to distinguish whitespace characters.
1056  *
1057  * Example:
1058  * @code
1059  * MyClass mc;
1060  *
1061  * std::cin >> std::ws >> mc;
1062  * @endcode
1063  * will skip leading whitespace before calling operator>> on cin and your
1064  * object. Note that the same effect can be achieved by creating a
1065  * std::basic_istream::sentry inside your definition of operator>>.
1066  */
1067  template<typename _CharT, typename _Traits>
1068  basic_istream<_CharT, _Traits>&
1069  ws(basic_istream<_CharT, _Traits>& __is);
1070 
1071 #if __cplusplus >= 201103L
1072  // C++11 27.7.2.6 Rvalue stream extraction [istream.rvalue]
1073  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1074  // 2328. Rvalue stream extraction should use perfect forwarding
1075  // 1203. More useful rvalue stream insertion
1076 
1077 #if __cpp_concepts >= 201907L && __glibcxx_type_trait_variable_templates
1078  template<typename _Is, typename _Tp>
1079  requires __derived_from_ios_base<_Is>
1080  && requires (_Is& __is, _Tp&& __t) { __is >> std::forward<_Tp>(__t); }
1081  using __rvalue_stream_extraction_t = _Is&&;
1082 #else
1083  template<typename _Is, typename _Tp,
1084  typename = _Require_derived_from_ios_base<_Is>,
1085  typename = decltype(std::declval<_Is&>() >> std::declval<_Tp>())>
1086  using __rvalue_stream_extraction_t = _Is&&;
1087 #endif
1088 
1089  /**
1090  * @brief Generic extractor for rvalue stream
1091  * @param __is An input stream.
1092  * @param __x A reference to the extraction target.
1093  * @return __is
1094  *
1095  * This is just a forwarding function to allow extraction from
1096  * rvalue streams since they won't bind to the extractor functions
1097  * that take an lvalue reference.
1098  */
1099  template<typename _Istream, typename _Tp>
1100  inline __rvalue_stream_extraction_t<_Istream, _Tp>
1101  operator>>(_Istream&& __is, _Tp&& __x)
1102  {
1103  __is >> std::forward<_Tp>(__x);
1104  return std::move(__is);
1105  }
1106 #endif // C++11
1107 
1108 _GLIBCXX_END_NAMESPACE_VERSION
1109 } // namespace
1110 
1111 #include <bits/istream.tcc>
1112 
1113 #endif /* _GLIBCXX_ISTREAM */