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

basic_ostream& operator<<( bool value );

basic_ostream& operator<<( long value );

basic_ostream& operator<<( unsigned long value );

basic_ostream& operator<<( long long value );

basic_ostream& operator<<( unsigned long long value );

basic_ostream& operator<<( double value );

basic_ostream& operator<<( long double value );

basic_ostream& operator<<( const void* value );

basic_ostream& operator<<( const volatile void* value );

basic_ostream& operator<<( std::nullptr_t );

basic_ostream& operator<<( short value );

basic_ostream& operator<<( int value );

basic_ostream& operator<<( unsigned short value );

basic_ostream& operator<<( unsigned int value );

basic_ostream& operator<<( float value );

basic_ostream& operator<<( /* extended-floating-point-type */ value );

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

basic_ostream& operator<<(
    std::ios_base& (*func)(std::ios_base&) );

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

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

Inserts data into the stream.

• static_cast<long>(static_cast<unsigned short>(value)), if flags() & std::ios_base::basefield is std::ios_base::oct or std::ios_base::hex, or
• static_cast<long>(value) otherwise.

• static_cast<long>(static_cast<unsigned int>(value)), if flags() & std::ios_base::basefield is std::ios_base::oct or std::ios_base::hex, or
• static_cast<long>(value) otherwise.

• If the rank is less than or equal to that of double, inserts static_cast<double>(value) as in (6).
• Otherwise, if the rank is less than or equal to that of longdouble, inserts static_cast<long double>(value) as in (7).
• Otherwise, an invocation of this overload is conditionally supported with implementation-defined semantics.

Parameters

Return value

Notes

There are no overloads for pointers to non-static members, pointers to volatiles,(until C++23) or function pointers (other than the ones with signatures accepted by the (18-20) overloads).

• Attempting to output such objects invokes implicit conversion to bool, and, for any non-null pointer value, the value 1 is printed (unless boolalpha was set, in which case true is printed).

Character and character string arguments (e.g., of type char or constchar*) are handled by the non-member overloads of operator<<.

• Attempting to output a character using the member function call syntax (e.g., std::cout.operator<<('c');) will call one of the overloads in (2-5) or (11-14) and output the numerical value.
• Attempting to output a character string using the member function call syntax will call overload (8) and print the pointer value instead.

Overload (10) was added by the resolution of LWG issue 2221, but it is never implemented in any standard library implementation under C++11/14 modes.

Example

#include <iomanip>
#include <iostream>
#include <sstream>

int fun() { return 42; }

int main()
{
    std::istringstream input(" \"Some text.\" ");
    double f = 3.14;
    bool b = true;
    
    std::cout
        << fun()          // int overload (12)
        << ' '            // non-member overload
        << std::boolalpha // function overload (18)
        << b              // bool overload (1)
        << " "            // non-member overload
        << std::fixed     // function overload (18) again
        << f              // double overload (6)
        << input.rdbuf()  // streambuf overload
        << fun            // bool overload (1): there's no overload for int(*)()
        << std::endl;     // function overload (18) again
    
    int x = 0;
    int* p1 = &x;
    volatile int* p2 = &x;
    std::cout
        << "p1: " << p1 << '\n'  // `const void*` overload, prints address
        << "p2: " << p2 << '\n'; // before C++23 (P1147): bool overload :), because
            // operator<<(const void*) is not a match, as it discards the `volatile`
            // qualifier. To fix this, C++23 adds `const volatile void*` overload (9),
            // that prints the address as expected.
}

42 true 3.140000 "Some text." true
p1: 0x7ffcea766600
p2: 0x7ffcea766600

Defect reports

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

See also