Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../algorithm/../io/basic_istream/operator_gtgt.html below:

std::basic_istream<CharT,Traits>::operator>> - cppreference.com

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>>( basic_istream& (*func)(basic_istream&) );

Extracts values from an input stream.

1-11) Extracts a value potentially skipping preceding whitespace. The value is stored to a given reference value.

12) Extracts a short value potentially skipping preceding whitespace. The value is stored to a given reference value.

13) Extracts an int value potentially skipping preceding whitespace. The value is stored to a given reference value.

Extracts an extended floating-point value potentially skipping preceding whitespace. The value is stored to a given reference

. The library provides overloads for all cv-unqualified

as the referenced type of the parameter

.

Determines the standard floating-point type

as follows:

• 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.

This function behaves as a

. After constructing and checking the sentry object, which may skip leading whitespace, extracts an

value

by calling

. After that:

• 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.

15-17) Calls func(*this), where func is an I/O manipulator.

Behaves as an

. After constructing and checking the sentry object, extracts all data from

and stores it to

. The extraction stops if one of the following conditions are met:

• end-of-file occurs on the input sequence;
• inserting in the output sequence fails (in which case the character to be inserted is not extracted);
• an exception occurs (in which case the exception is caught, and only rethrown if it inserted no characters and failbit is enabled in exceptions()).

In either case, stores the number of characters extracted in the member variable accessed by subsequent calls to

. If

is a null pointer or if no characters were inserted into

, calls

(which may throw

if enabled).

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.

1-16,18) *this

17) func(*this)

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.

#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';
}

Output:

n = 41
f = 3.14
b = false
hello world

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4