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

From cppreference.com
< cpp‎ | io‎ | basic ostream

basic_ostream& operator<<( short value ); basic_ostream& operator<<( unsigned short value ); | (1) |
basic_ostream& operator<<( int value ); basic_ostream& operator<<( unsigned int value ); | (2) |
basic_ostream& operator<<( long value ); basic_ostream& operator<<( unsigned long value ); | (3) |
basic_ostream& operator<<( long long value ); basic_ostream& operator<<( unsigned long long value ); | (4) | (since C++11)
basic_ostream& operator<<( float value ); basic_ostream& operator<<( double value ); basic_ostream& operator<<( long double value ); | (5) |
basic_ostream& operator<<( bool value ); | (6) |
basic_ostream& operator<<( const void* value ); | (7) |
basic_ostream& operator<<( std::nullptr_t ); | (8) | (since C++17)
basic_ostream& operator<<( std::basic_streambuf <CharT, Traits>* sb); | (9) |
basic_ostream& operator<<( std::ios_base & (*func)( std::ios_base &) ); | (10) |
basic_ostream& operator<<( std::basic_ios <CharT,Traits>& (*func)( std::basic_ios <CharT,Traits>&) ); | (11) |
basic_ostream& operator<<( std::basic_ostream <CharT,Traits>& (*func)( std::basic_ostream <CharT,Traits>&) ); | (12) |

Inserts data into the stream.

1-2) Behaves as a FormattedOutputFunction. After constructing and checking the sentry object, if `value` is short or int, then casts it to unsigned short or unsigned int if ios_base::flags() & ios_base::basefield is ios_base::oct or ios_base::hex. After that, casts to long in any case and outputs as in (3). If `value` is unsigned short or unsigned int, casts to unsigned long and outputs as in (3).
3-7) Behaves as a FormattedOutputFunction. After constructing and checking the sentry object, inserts an integer, floating point, boolean or generic pointer value by calling `num_put::put()`. If the end of file condition was encountered during output (put().failed() == true), sets ios::badbit.
8) Outputs an implementation-defined string as if by `*this << s`, where `s` is a null-terminated character type string.
9) Behaves as an UnformattedOutputFunction. After constructing and checking the sentry object, checks if `sb` is a null pointer. If it is, executes setstate(badbit) and exits. Otherwise, extracts characters from the input sequence controlled by `sb` and inserts them into *this until 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).

If no characters were inserted, executes setstate(failbit). If an exception was thrown while extracting, sets failbit and, if `failbit` is set in exceptions(), rethrows the exception.
10-12) Calls func(*this). These overloads are used to implement output I/O manipulators such as std::endl.

### Parameters

value | - | integer, floating-point, boolean, or pointer value to insert
func | - | function to call
sb | - | pointer to the streambuffer to read the data from

### Return value

1-11) *this
12) func(*this)

### Notes

There are no overload for pointers to non-static member, pointers to volatile, or function pointers (other than the ones with signatures accepted by the (10-12) 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 const char*) 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 overloads (2-4) and output the numerical value. Attempting to output a character string using the member function call syntax will call overload (7) and print the pointer value instead.

### Example

Run this code

    #include <iostream>
    #include <iomanip>
    #include <sstream>
    int main()
    {
        std::istringstream input(" \"Some text.\" ");
        volatile int n = 42;
        double f = 3.14;
        bool b = true;
        std::cout << n   // int overload
                  << ' ' // non-member overload
                  << std::boolalpha << b // bool overload
                  << " " // non-member overload
                  << std::fixed << f // double overload
                  << input.rdbuf() // streambuf overload
                  << &n // bool overload: volatile int* doesn't convert to const void*
                  << std::endl; // function overload
    }

Output:

    42 true 3.140000 "Some text." true

### See also

operator<<(std::basic_ostream) | inserts character data (function template)
operator<<operator>> | performs stream I/O of strings (function template)
operator<<operator>> | performs stream input and output of bitsets (function)
operator<<operator>> | serializes and deserializes a complex number (function template)
operator<<operator>> | performs stream input and output on pseudo-random number engine (function template)
operator<<operator>> | performs stream input and output on pseudo-random number distribution (function template)
put | inserts a character (public member function)
write | inserts blocks of characters (public member function)
to_chars (C++17) | converts an integer or floating-point value to a character sequence (function)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/io/basic_ostream/operator_ltlt&oldid=106140"