std::basic_istream<CharT,Traits>::operator>>

basic_istream& operator>>( unsigned short& value );

basic_istream& operator>>( unsigned int& value );

basic_istream& operator>>( long& value );

basic_istream& operator>>( unsigned long& value );

basic_istream& operator>>( long long& value );

basic_istream& operator>>( unsigned long long& value );

basic_istream& operator>>( float& value );

basic_istream& operator>>( double& value );

basic_istream& operator>>( long double& value );

basic_istream& operator>>( bool& value );

basic_istream& operator>>( void*& value );

basic_istream& operator>>( short& value );

basic_istream& operator>>( int& value );

basic_istream& operator>>( /* extended-floating-point-type */& value );

basic_istream& operator>>( std::ios_base& (*func)(std::ios_base&) );

basic_istream& operator>>( std::basic_ios<CharT, Traits>& 
                               (*func)(std::basic_ios<CharT, Traits>&) );

basic_istream& operator>>( basic_istream& (*func)(basic_istream&) );

basic_istream& operator>>( std::basic_streambuf<CharT, Traits>* sb );

Extracts values from an input stream.

• If lval < std::numeric_limits<short>::min(), sets failbit and stores std::numeric_limits<short>::min() to val.
• Otherwise, if std::numeric_limits<short>::max() < lval, sets failbit and stores std::numeric_limits<short>::max() to val.
• Otherwise, stores static_cast<short>(lval) to val.

• If lval < std::numeric_limits<int>::min(), sets failbit and stores std::numeric_limits<int>::min() to val.
• Otherwise, if std::numeric_limits<int>::max() < lval, sets failbit and stores std::numeric_limits<int>::max() to val.
• Otherwise, stores static_cast<int>(lval) to val.

• If the floating-point conversion rank of /* extended-floating-point-type */ is less than or equal to that of float, then FP is float.
• Otherwise, if the floating-point conversion rank of /* extended-floating-point-type */ is less than or equal to that of double, then FP is double.
• Otherwise, FP is long double.

• If fval < -std::numeric_limits</* extended-floating-point-type */>::max(), sets failbit and stores -std::numeric_limits</* extended-floating-point-type */>::max() to val.
• Otherwise, if std::numeric_limits</* extended-floating-point-type */>::max() < fval, sets failbit and stores std::numeric_limits</* extended-floating-point-type */>::max() to val.
• Otherwise, stores static_cast</* extended-floating-point-type */>(fval) to val.

If extraction fails (e.g. if a letter was entered where a digit is expected), zero is written to value and failbit is set. For signed integers, if extraction results in the value too large or too small to fit in value, std::numeric_limits<T>::max() or std::numeric_limits<T>::min() (respectively) is written and failbit flag is set. For unsigned integers, if extraction results in the value too large or too small to fit in value, std::numeric_limits<T>::max() is written and failbit flag is set.

Parameters

Return value

Notes

For overload (14), when the extended floating-point type has a floating-point conversion rank that is not equal to the rank of any standard floating-point type, then double rounding during the conversion can result in inaccurate results. std::from_chars() can be used in situations where maximum accuracy is important.

Example

#include <iomanip>
#include <iostream>
#include <sstream>
 
int main()
{
    std::string input = "41 3.14 false hello world";
    std::istringstream stream(input);
 
    int n;
    double f;
    bool b;
 
    stream >> n >> f >> std::boolalpha >> b;
    std::cout << "n = " << n << '\n'
              << "f = " << f << '\n'
              << "b = " << std::boolalpha << b << '\n';
 
    // extract the rest using the streambuf overload
    stream >> std::cout.rdbuf();
    std::cout << '\n';
}

n = 41
f = 3.14
b = false
hello world

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also