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