std::basic_ostream::operator<<

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

Input/output library

I/O manipulators

C-style I/O

Buffers

basic_streambuf

basic_filebuf

basic_stringbuf

strstreambuf (deprecated)

Streams

Abstractions

ios_base

basic_ios

basic_istream

basic_ostream

basic_iostream

File I/O

basic_ifstream

basic_ofstream

basic_fstream

String I/O

basic_istringstream

basic_ostringstream

basic_stringstream

Array I/O

istrstream (deprecated)

ostrstream (deprecated)

strstream (deprecated)

Types

streamoff

streamsize

fpos

Error category interface

iostream_category (C++11)

io_errc (C++11)

 

std::basic_ostream

Global objects
coutwcout	cerrwcerr	clogwclog
Member functions
basic_ostream::basic_ostream
basic_ostream::~basic_ostream
basic_ostream::operator= (C++11)
Formatted output
basic_ostream::operator<<
Unformatted output
basic_ostream::put
basic_ostream::write
Positioning
basic_ostream::tellp
basic_ostream::seekp
Miscellaneous
basic_ostream::flush
basic_ostream::swap (C++11)
Member classes
basic_ostream::sentry
Non-member functions
operator<<(std::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::basic_streambuf<CharT, Traits>* sb);	(8)
	(9)
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.

1-2) Behaves as an 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 an 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) 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(badbit). If an exception was thrown while extracting, sets failbit

9) 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

*this

Notes

There are no overload for pointers to volatile or function pointers (other than the ones with signatures accepted by the (9) overload). 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).

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
              << 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)