1 // Input streams -*- C++ -*- 2 3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 4 // 2006, 2007, 2008, 2009, 2010, 2011 5 // Free Software Foundation, Inc. 6 // 7 // This file is part of the GNU ISO C++ Library. This library is free 8 // software; you can redistribute it and/or modify it under the 9 // terms of the GNU General Public License as published by the 10 // Free Software Foundation; either version 3, or (at your option) 11 // any later version. 12 13 // This library is distributed in the hope that it will be useful, 14 // but WITHOUT ANY WARRANTY; without even the implied warranty of 15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 // GNU General Public License for more details. 17 18 // Under Section 7 of GPL version 3, you are granted additional 19 // permissions described in the GCC Runtime Library Exception, version 20 // 3.1, as published by the Free Software Foundation. 21 22 // You should have received a copy of the GNU General Public License and 23 // a copy of the GCC Runtime Library Exception along with this program; 24 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 25 // <http://www.gnu.org/licenses/>. 26 27 // 28 // ISO C++ 14882: 27.6.1 Input streams 29 // 30 31 /** @file include/istream 32 * This is a Standard C++ Library header. 33 */ 34 35 #ifndef _GLIBCXX_ISTREAM 36 #define _GLIBCXX_ISTREAM 1 37 38 #pragma GCC system_header 39 40 #include <ios> 41 #include <ostream> 42 43 namespace std _GLIBCXX_VISIBILITY(default) 44 { 45 _GLIBCXX_BEGIN_NAMESPACE_VERSION 46 47 // [27.6.1.1] Template class basic_istream 48 /** 49 * @brief Controlling input. 50 * @ingroup io 51 * 52 * This is the base class for all input streams. It provides text 53 * formatting of all builtin types, and communicates with any class 54 * derived from basic_streambuf to do the actual input. 55 */ 56 template<typename _CharT, typename _Traits> 57 class basic_istream : virtual public basic_ios<_CharT, _Traits> 58 { 59 public: 60 // Types (inherited from basic_ios (27.4.4)): 61 typedef _CharT char_type; 62 typedef typename _Traits::int_type int_type; 63 typedef typename _Traits::pos_type pos_type; 64 typedef typename _Traits::off_type off_type; 65 typedef _Traits traits_type; 66 67 // Non-standard Types: 68 typedef basic_streambuf<_CharT, _Traits> __streambuf_type; 69 typedef basic_ios<_CharT, _Traits> __ios_type; 70 typedef basic_istream<_CharT, _Traits> __istream_type; 71 typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > 72 __num_get_type; 73 typedef ctype<_CharT> __ctype_type; 74 75 protected: 76 // Data Members: 77 /** 78 * The number of characters extracted in the previous unformatted 79 * function; see gcount(). 80 */ 81 streamsize _M_gcount; 82 83 public: 84 // [27.6.1.1.1] constructor/destructor 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 103 ~basic_istream() 104 { _M_gcount = streamsize(0); } 105 106 // [27.6.1.1.2] prefix/suffix 107 class sentry; 108 friend class sentry; 109 110 // [27.6.1.2] formatted input 111 // [27.6.1.2.3] basic_istream::operator>> 112 //@{ 113 /** 114 * @brief Interface for manipulators. 115 * 116 * Manipulators such as @c std::ws and @c std::dec use these 117 * functions in constructs like 118 * <code>std::cin >> std::ws</code>. 119 * For more information, see the iomanip header. 120 */ 121 __istream_type& 122 operator>>(__istream_type& (*__pf)(__istream_type&)) 123 { return __pf(*this); } 124 125 __istream_type& 126 operator>>(__ios_type& (*__pf)(__ios_type&)) 127 { 128 __pf(*this); 129 return *this; 130 } 131 132 __istream_type& 133 operator>>(ios_base& (*__pf)(ios_base&)) 134 { 135 __pf(*this); 136 return *this; 137 } 138 //@} 139 140 // [27.6.1.2.2] arithmetic extractors 141 /** 142 * @name Arithmetic Extractors 143 * 144 * All the @c operator>> functions (aka <em>formatted input 145 * functions</em>) have some common behavior. Each starts by 146 * constructing a temporary object of type std::basic_istream::sentry 147 * with the second argument (noskipws) set to false. This has several 148 * effects, concluding with the setting of a status flag; see the 149 * sentry documentation for more. 150 * 151 * If the sentry status is good, the function tries to extract 152 * whatever data is appropriate for the type of the argument. 153 * 154 * If an exception is thrown during extraction, ios_base::badbit 155 * will be turned on in the stream's error state without causing an 156 * ios_base::failure to be thrown. The original exception will then 157 * be rethrown. 158 */ 159 //@{ 160 /** 161 * @brief Basic arithmetic extractors 162 * @param A variable of builtin type. 163 * @return @c *this if successful 164 * 165 * These functions use the stream's current locale (specifically, the 166 * @c num_get facet) to parse the input data. 167 */ 168 __istream_type& 169 operator>>(bool& __n) 170 { return _M_extract(__n); } 171 172 __istream_type& 173 operator>>(short& __n); 174 175 __istream_type& 176 operator>>(unsigned short& __n) 177 { return _M_extract(__n); } 178 179 __istream_type& 180 operator>>(int& __n); 181 182 __istream_type& 183 operator>>(unsigned int& __n) 184 { return _M_extract(__n); } 185 186 __istream_type& 187 operator>>(long& __n) 188 { return _M_extract(__n); } 189 190 __istream_type& 191 operator>>(unsigned long& __n) 192 { return _M_extract(__n); } 193 194 #ifdef _GLIBCXX_USE_LONG_LONG 195 __istream_type& 196 operator>>(long long& __n) 197 { return _M_extract(__n); } 198 199 __istream_type& 200 operator>>(unsigned long long& __n) 201 { return _M_extract(__n); } 202 #endif 203 204 __istream_type& 205 operator>>(float& __f) 206 { return _M_extract(__f); } 207 208 __istream_type& 209 operator>>(double& __f) 210 { return _M_extract(__f); } 211 212 __istream_type& 213 operator>>(long double& __f) 214 { return _M_extract(__f); } 215 216 __istream_type& 217 operator>>(void*& __p) 218 { return _M_extract(__p); } 219 220 /** 221 * @brief Extracting into another streambuf. 222 * @param sb A pointer to a streambuf 223 * 224 * This function behaves like one of the basic arithmetic extractors, 225 * in that it also constructs a sentry object and has the same error 226 * handling behavior. 227 * 228 * If @a sb is NULL, the stream will set failbit in its error state. 229 * 230 * Characters are extracted from this stream and inserted into the 231 * @a sb streambuf until one of the following occurs: 232 * 233 * - the input stream reaches end-of-file, 234 * - insertion into the output buffer fails (in this case, the 235 * character that would have been inserted is not extracted), or 236 * - an exception occurs (and in this case is caught) 237 * 238 * If the function inserts no characters, failbit is set. 239 */ 240 __istream_type& 241 operator>>(__streambuf_type* __sb); 242 //@} 243 244 // [27.6.1.3] unformatted input 245 /** 246 * @brief Character counting 247 * @return The number of characters extracted by the previous 248 * unformatted input function dispatched for this stream. 249 */ 250 streamsize 251 gcount() const 252 { return _M_gcount; } 253 254 /** 255 * @name Unformatted Input Functions 256 * 257 * All the unformatted input functions have some common behavior. 258 * Each starts by constructing a temporary object of type 259 * std::basic_istream::sentry with the second argument (noskipws) 260 * set to true. This has several effects, concluding with the 261 * setting of a status flag; see the sentry documentation for more. 262 * 263 * If the sentry status is good, the function tries to extract 264 * whatever data is appropriate for the type of the argument. 265 * 266 * The number of characters extracted is stored for later retrieval 267 * by gcount(). 268 * 269 * If an exception is thrown during extraction, ios_base::badbit 270 * will be turned on in the stream's error state without causing an 271 * ios_base::failure to be thrown. The original exception will then 272 * be rethrown. 273 */ 274 //@{ 275 /** 276 * @brief Simple extraction. 277 * @return A character, or eof(). 278 * 279 * Tries to extract a character. If none are available, sets failbit 280 * and returns traits::eof(). 281 */ 282 int_type 283 get(); 284 285 /** 286 * @brief Simple extraction. 287 * @param c The character in which to store data. 288 * @return *this 289 * 290 * Tries to extract a character and store it in @a c. If none are 291 * available, sets failbit and returns traits::eof(). 292 * 293 * @note This function is not overloaded on signed char and 294 * unsigned char. 295 */ 296 __istream_type& 297 get(char_type& __c); 298 299 /** 300 * @brief Simple multiple-character extraction. 301 * @param s Pointer to an array. 302 * @param n Maximum number of characters to store in @a s. 303 * @param delim A "stop" character. 304 * @return *this 305 * 306 * Characters are extracted and stored into @a s until one of the 307 * following happens: 308 * 309 * - @c n-1 characters are stored 310 * - the input sequence reaches EOF 311 * - the next character equals @a delim, in which case the character 312 * is not extracted 313 * 314 * If no characters are stored, failbit is set in the stream's error 315 * state. 316 * 317 * In any case, a null character is stored into the next location in 318 * the array. 319 * 320 * @note This function is not overloaded on signed char and 321 * unsigned char. 322 */ 323 __istream_type& 324 get(char_type* __s, streamsize __n, char_type __delim); 325 326 /** 327 * @brief Simple multiple-character extraction. 328 * @param s Pointer to an array. 329 * @param n Maximum number of characters to store in @a s. 330 * @return *this 331 * 332 * Returns @c get(s,n,widen('\\n')). 333 */ 334 __istream_type& 335 get(char_type* __s, streamsize __n) 336 { return this->get(__s, __n, this->widen('\n')); } 337 338 /** 339 * @brief Extraction into another streambuf. 340 * @param sb A streambuf in which to store data. 341 * @param delim A "stop" character. 342 * @return *this 343 * 344 * Characters are extracted and inserted into @a sb until one of the 345 * following happens: 346 * 347 * - the input sequence reaches EOF 348 * - insertion into the output buffer fails (in this case, the 349 * character that would have been inserted is not extracted) 350 * - the next character equals @a delim (in this case, the character 351 * is not extracted) 352 * - an exception occurs (and in this case is caught) 353 * 354 * If no characters are stored, failbit is set in the stream's error 355 * state. 356 */ 357 __istream_type& 358 get(__streambuf_type& __sb, char_type __delim); 359 360 /** 361 * @brief Extraction into another streambuf. 362 * @param sb A streambuf in which to store data. 363 * @return *this 364 * 365 * Returns @c get(sb,widen('\\n')). 366 */ 367 __istream_type& 368 get(__streambuf_type& __sb) 369 { return this->get(__sb, this->widen('\n')); } 370 371 /** 372 * @brief String extraction. 373 * @param s A character array in which to store the data. 374 * @param n Maximum number of characters to extract. 375 * @param delim A "stop" character. 376 * @return *this 377 * 378 * Extracts and stores characters into @a s until one of the 379 * following happens. Note that these criteria are required to be 380 * tested in the order listed here, to allow an input line to exactly 381 * fill the @a s array without setting failbit. 382 * 383 * -# the input sequence reaches end-of-file, in which case eofbit 384 * is set in the stream error state 385 * -# the next character equals @c delim, in which case the character 386 * is extracted (and therefore counted in @c gcount()) but not stored 387 * -# @c n-1 characters are stored, in which case failbit is set 388 * in the stream error state 389 * 390 * If no characters are extracted, failbit is set. (An empty line of 391 * input should therefore not cause failbit to be set.) 392 * 393 * In any case, a null character is stored in the next location in 394 * the array. 395 */ 396 __istream_type& 397 getline(char_type* __s, streamsize __n, char_type __delim); 398 399 /** 400 * @brief String extraction. 401 * @param s A character array in which to store the data. 402 * @param n Maximum number of characters to extract. 403 * @return *this 404 * 405 * Returns @c getline(s,n,widen('\\n')). 406 */ 407 __istream_type& 408 getline(char_type* __s, streamsize __n) 409 { return this->getline(__s, __n, this->widen('\n')); } 410 411 /** 412 * @brief Discarding characters 413 * @param n Number of characters to discard. 414 * @param delim A "stop" character. 415 * @return *this 416 * 417 * Extracts characters and throws them away until one of the 418 * following happens: 419 * - if @a n @c != @c std::numeric_limits<int>::max(), @a n 420 * characters are extracted 421 * - the input sequence reaches end-of-file 422 * - the next character equals @a delim (in this case, the character 423 * is extracted); note that this condition will never occur if 424 * @a delim equals @c traits::eof(). 425 * 426 * NB: Provide three overloads, instead of the single function 427 * (with defaults) mandated by the Standard: this leads to a 428 * better performing implementation, while still conforming to 429 * the Standard. 430 */ 431 __istream_type& 432 ignore(); 433 434 __istream_type& 435 ignore(streamsize __n); 436 437 __istream_type& 438 ignore(streamsize __n, int_type __delim); 439 440 /** 441 * @brief Looking ahead in the stream 442 * @return The next character, or eof(). 443 * 444 * If, after constructing the sentry object, @c good() is false, 445 * returns @c traits::eof(). Otherwise reads but does not extract 446 * the next input character. 447 */ 448 int_type 449 peek(); 450 451 /** 452 * @brief Extraction without delimiters. 453 * @param s A character array. 454 * @param n Maximum number of characters to store. 455 * @return *this 456 * 457 * If the stream state is @c good(), extracts characters and stores 458 * them into @a s until one of the following happens: 459 * - @a n characters are stored 460 * - the input sequence reaches end-of-file, in which case the error 461 * state is set to @c failbit|eofbit. 462 * 463 * @note This function is not overloaded on signed char and 464 * unsigned char. 465 */ 466 __istream_type& 467 read(char_type* __s, streamsize __n); 468 469 /** 470 * @brief Extraction until the buffer is exhausted, but no more. 471 * @param s A character array. 472 * @param n Maximum number of characters to store. 473 * @return The number of characters extracted. 474 * 475 * Extracts characters and stores them into @a s depending on the 476 * number of characters remaining in the streambuf's buffer, 477 * @c rdbuf()->in_avail(), called @c A here: 478 * - if @c A @c == @c -1, sets eofbit and extracts no characters 479 * - if @c A @c == @c 0, extracts no characters 480 * - if @c A @c > @c 0, extracts @c min(A,n) 481 * 482 * The goal is to empty the current buffer, and to not request any 483 * more from the external input sequence controlled by the streambuf. 484 */ 485 streamsize 486 readsome(char_type* __s, streamsize __n); 487 488 /** 489 * @brief Unextracting a single character. 490 * @param c The character to push back into the input stream. 491 * @return *this 492 * 493 * If @c rdbuf() is not null, calls @c rdbuf()->sputbackc(c). 494 * 495 * If @c rdbuf() is null or if @c sputbackc() fails, sets badbit in 496 * the error state. 497 * 498 * @note This function first clears eofbit. Since no characters 499 * are extracted, the next call to @c gcount() will return 0, 500 * as required by DR 60. 501 */ 502 __istream_type& 503 putback(char_type __c); 504 505 /** 506 * @brief Unextracting the previous character. 507 * @return *this 508 * 509 * If @c rdbuf() is not null, calls @c rdbuf()->sungetc(c). 510 * 511 * If @c rdbuf() is null or if @c sungetc() fails, sets badbit in 512 * the error state. 513 * 514 * @note This function first clears eofbit. Since no characters 515 * are extracted, the next call to @c gcount() will return 0, 516 * as required by DR 60. 517 */ 518 __istream_type& 519 unget(); 520 521 /** 522 * @brief Synchronizing the stream buffer. 523 * @return 0 on success, -1 on failure 524 * 525 * If @c rdbuf() is a null pointer, returns -1. 526 * 527 * Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1, 528 * sets badbit and returns -1. 529 * 530 * Otherwise, returns 0. 531 * 532 * @note This function does not count the number of characters 533 * extracted, if any, and therefore does not affect the next 534 * call to @c gcount(). 535 */ 536 int 537 sync(); 538 539 /** 540 * @brief Getting the current read position. 541 * @return A file position object. 542 * 543 * If @c fail() is not false, returns @c pos_type(-1) to indicate 544 * failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,in). 545 * 546 * @note This function does not count the number of characters 547 * extracted, if any, and therefore does not affect the next 548 * call to @c gcount(). At variance with putback, unget and 549 * seekg, eofbit is not cleared first. 550 */ 551 pos_type 552 tellg(); 553 554 /** 555 * @brief Changing the current read position. 556 * @param pos A file position object. 557 * @return *this 558 * 559 * If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If 560 * that function fails, sets failbit. 561 * 562 * @note This function first clears eofbit. It does not count the 563 * number of characters extracted, if any, and therefore does 564 * not affect the next call to @c gcount(). 565 */ 566 __istream_type& 567 seekg(pos_type); 568 569 /** 570 * @brief Changing the current read position. 571 * @param off A file offset object. 572 * @param dir The direction in which to seek. 573 * @return *this 574 * 575 * If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir). 576 * If that function fails, sets failbit. 577 * 578 * @note This function first clears eofbit. It does not count the 579 * number of characters extracted, if any, and therefore does 580 * not affect the next call to @c gcount(). 581 */ 582 __istream_type& 583 seekg(off_type, ios_base::seekdir); 584 //@} 585 586 protected: 587 basic_istream() 588 : _M_gcount(streamsize(0)) 589 { this->init(0); } 590 591 template<typename _ValueT> 592 __istream_type& 593 _M_extract(_ValueT& __v); 594 }; 595 596 // Explicit specialization declarations, defined in src/istream.cc. 597 template<> 598 basic_istream<char>& 599 basic_istream<char>:: 600 getline(char_type* __s, streamsize __n, char_type __delim); 601 602 template<> 603 basic_istream<char>& 604 basic_istream<char>:: 605 ignore(streamsize __n); 606 607 template<> 608 basic_istream<char>& 609 basic_istream<char>:: 610 ignore(streamsize __n, int_type __delim); 611 612 #ifdef _GLIBCXX_USE_WCHAR_T 613 template<> 614 basic_istream<wchar_t>& 615 basic_istream<wchar_t>:: 616 getline(char_type* __s, streamsize __n, char_type __delim); 617 618 template<> 619 basic_istream<wchar_t>& 620 basic_istream<wchar_t>:: 621 ignore(streamsize __n); 622 623 template<> 624 basic_istream<wchar_t>& 625 basic_istream<wchar_t>:: 626 ignore(streamsize __n, int_type __delim); 627 #endif 628 629 /** 630 * @brief Performs setup work for input streams. 631 * 632 * Objects of this class are created before all of the standard 633 * extractors are run. It is responsible for <em>exception-safe 634 * prefix and suffix operations,</em> although only prefix actions 635 * are currently required by the standard. 636 */ 637 template<typename _CharT, typename _Traits> 638 class basic_istream<_CharT, _Traits>::sentry 639 { 640 // Data Members. 641 bool _M_ok; 642 643 public: 644 /// Easy access to dependant types. 645 typedef _Traits traits_type; 646 typedef basic_streambuf<_CharT, _Traits> __streambuf_type; 647 typedef basic_istream<_CharT, _Traits> __istream_type; 648 typedef typename __istream_type::__ctype_type __ctype_type; 649 typedef typename _Traits::int_type __int_type; 650 651 /** 652 * @brief The constructor performs all the work. 653 * @param is The input stream to guard. 654 * @param noskipws Whether to consume whitespace or not. 655 * 656 * If the stream state is good (@a is.good() is true), then the 657 * following actions are performed, otherwise the sentry state 658 * is false (<em>not okay</em>) and failbit is set in the 659 * stream state. 660 * 661 * The sentry's preparatory actions are: 662 * 663 * -# if the stream is tied to an output stream, @c is.tie()->flush() 664 * is called to synchronize the output sequence 665 * -# if @a noskipws is false, and @c ios_base::skipws is set in 666 * @c is.flags(), the sentry extracts and discards whitespace 667 * characters from the stream. The currently imbued locale is 668 * used to determine whether each character is whitespace. 669 * 670 * If the stream state is still good, then the sentry state becomes 671 * true (@a okay). 672 */ 673 explicit 674 sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); 675 676 /** 677 * @brief Quick status checking. 678 * @return The sentry state. 679 * 680 * For ease of use, sentries may be converted to booleans. The 681 * return value is that of the sentry state (true == okay). 682 */ 683 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 684 explicit 685 #endif 686 operator bool() const 687 { return _M_ok; } 688 }; 689 690 // [27.6.1.2.3] character extraction templates 691 //@{ 692 /** 693 * @brief Character extractors 694 * @param in An input stream. 695 * @param c A character reference. 696 * @return in 697 * 698 * Behaves like one of the formatted arithmetic extractors described in 699 * std::basic_istream. After constructing a sentry object with good 700 * status, this function extracts a character (if one is available) and 701 * stores it in @a c. Otherwise, sets failbit in the input stream. 702 */ 703 template<typename _CharT, typename _Traits> 704 basic_istream<_CharT, _Traits>& 705 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); 706 707 template<class _Traits> 708 inline basic_istream<char, _Traits>& 709 operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c) 710 { return (__in >> reinterpret_cast<char&>(__c)); } 711 712 template<class _Traits> 713 inline basic_istream<char, _Traits>& 714 operator>>(basic_istream<char, _Traits>& __in, signed char& __c) 715 { return (__in >> reinterpret_cast<char&>(__c)); } 716 //@} 717 718 //@{ 719 /** 720 * @brief Character string extractors 721 * @param in An input stream. 722 * @param s A pointer to a character array. 723 * @return in 724 * 725 * Behaves like one of the formatted arithmetic extractors described in 726 * std::basic_istream. After constructing a sentry object with good 727 * status, this function extracts up to @c n characters and stores them 728 * into the array starting at @a s. @c n is defined as: 729 * 730 * - if @c width() is greater than zero, @c n is width() otherwise 731 * - @c n is <em>the number of elements of the largest array of * 732 * - @c char_type that can store a terminating @c eos.</em> 733 * - [27.6.1.2.3]/6 734 * 735 * Characters are extracted and stored until one of the following happens: 736 * - @c n-1 characters are stored 737 * - EOF is reached 738 * - the next character is whitespace according to the current locale 739 * - the next character is a null byte (i.e., @c charT() ) 740 * 741 * @c width(0) is then called for the input stream. 742 * 743 * If no characters are extracted, sets failbit. 744 */ 745 template<typename _CharT, typename _Traits> 746 basic_istream<_CharT, _Traits>& 747 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s); 748 749 // Explicit specialization declaration, defined in src/istream.cc. 750 template<> 751 basic_istream<char>& 752 operator>>(basic_istream<char>& __in, char* __s); 753 754 template<class _Traits> 755 inline basic_istream<char, _Traits>& 756 operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s) 757 { return (__in >> reinterpret_cast<char*>(__s)); } 758 759 template<class _Traits> 760 inline basic_istream<char, _Traits>& 761 operator>>(basic_istream<char, _Traits>& __in, signed char* __s) 762 { return (__in >> reinterpret_cast<char*>(__s)); } 763 //@} 764 765 // 27.6.1.5 Template class basic_iostream 766 /** 767 * @brief Merging istream and ostream capabilities. 768 * @ingroup io 769 * 770 * This class multiply inherits from the input and output stream classes 771 * simply to provide a single interface. 772 */ 773 template<typename _CharT, typename _Traits> 774 class basic_iostream 775 : public basic_istream<_CharT, _Traits>, 776 public basic_ostream<_CharT, _Traits> 777 { 778 public: 779 // _GLIBCXX_RESOLVE_LIB_DEFECTS 780 // 271. basic_iostream missing typedefs 781 // Types (inherited): 782 typedef _CharT char_type; 783 typedef typename _Traits::int_type int_type; 784 typedef typename _Traits::pos_type pos_type; 785 typedef typename _Traits::off_type off_type; 786 typedef _Traits traits_type; 787 788 // Non-standard Types: 789 typedef basic_istream<_CharT, _Traits> __istream_type; 790 typedef basic_ostream<_CharT, _Traits> __ostream_type; 791 792 /** 793 * @brief Constructor does nothing. 794 * 795 * Both of the parent classes are initialized with the same 796 * streambuf pointer passed to this constructor. 797 */ 798 explicit 799 basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) 800 : __istream_type(__sb), __ostream_type(__sb) { } 801 802 /** 803 * @brief Destructor does nothing. 804 */ 805 virtual 806 ~basic_iostream() { } 807 808 protected: 809 basic_iostream() 810 : __istream_type(), __ostream_type() { } 811 }; 812 813 // [27.6.1.4] standard basic_istream manipulators 814 /** 815 * @brief Quick and easy way to eat whitespace 816 * 817 * This manipulator extracts whitespace characters, stopping when the 818 * next character is non-whitespace, or when the input sequence is empty. 819 * If the sequence is empty, @c eofbit is set in the stream, but not 820 * @c failbit. 821 * 822 * The current locale is used to distinguish whitespace characters. 823 * 824 * Example: 825 * @code 826 * MyClass mc; 827 * 828 * std::cin >> std::ws >> mc; 829 * @endcode 830 * will skip leading whitespace before calling operator>> on cin and your 831 * object. Note that the same effect can be achieved by creating a 832 * std::basic_istream::sentry inside your definition of operator>>. 833 */ 834 template<typename _CharT, typename _Traits> 835 basic_istream<_CharT, _Traits>& 836 ws(basic_istream<_CharT, _Traits>& __is); 837 838 #ifdef __GXX_EXPERIMENTAL_CXX0X__ 839 // [27.7.1.6] Rvalue stream extraction 840 /** 841 * @brief Generic extractor for rvalue stream 842 * @param is An input stream. 843 * @param x A reference to the extraction target. 844 * @return is 845 * 846 * This is just a forwarding function to allow extraction from 847 * rvalue streams since they won't bind to the extractor functions 848 * that take an lvalue reference. 849 */ 850 template<typename _CharT, typename _Traits, typename _Tp> 851 inline basic_istream<_CharT, _Traits>& 852 operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x) 853 { return (__is >> __x); } 854 #endif // __GXX_EXPERIMENTAL_CXX0X__ 855 856 _GLIBCXX_END_NAMESPACE_VERSION 857 } // namespace 858 859 #include <bits/istream.tcc> 860 861 #endif /* _GLIBCXX_ISTREAM */ 862
