Streamler std::ostream Sınıfı - std::cout

Giriş
Şu satırı dahil etmek gerekir.

#include <iostream>

ostream sınıfı bir typedef'ten ibaret.

typedef basic_ostream<char> ostream;

std::cout Nedir
std::cout aslında bir ostream.Tanımlaması şöyle

extern std::ostream cout;

Açıklaması şöyle.

std::cout and std::cin are global objects of classes std::ostream and std::istream respectively, which they've overloaded operator << and >>.

Dolayısıyla std::ostream sınıfının tüm metodlarını kullanmak mümkün.

Neden std::cout ve std::cerr Farklı
Açıklaması şöyle.

One of the most amusing and unexpected consequences of phototypesetting was the Unix standard error file (!). After phototypesetting, you had to take a long wide strip of paper and feed it carefully into a smelly, icky machine which eventually (several minutes later) spat out the paper with the printing visible.

One afternoon several of us had the same experience -- typesetting something, feeding the paper through the developer, only to find a single, beautifully typeset line: "cannot open file foobar" The grumbles were loud enough and in the presence of the right people, and a couple of days later the standard error file was born...

default constructor
Bu sınıfın default constructor metodu yoktur. Kullanmaya çalışırsak şu hatayı alırız.

'std::basic_ostream>': no appropriate default >constructor available

copy constructor
Bu sınıfın default constructor metodu yoktur. Ancak şöyle yapılabilir. Aşağıdaki sınıf aynı rfbuf nesnesini kullanır.

struct cloned_ostream : std::ostream {

    cloned_ostream( std::ostream const & in )
        : std::ostream( in.rdbuf() ) {

        copyfmt( in );
        clear( in.rdstate() );
    }
};

Böylece bir stream'in kısa ömürlü bir kopyası yaratılabilir. Bu kısa ömürlü kopya aynı rdbuf nesnesine yazdığı için formatlama işlemlerinde kullanılabilir.

std::ostream & operator << ( std::ostream & os, foo const & smth ) {
    cloned_ostream cs( os );
    cs << std::hex << smth.num;
    // os is not switched to hexadecimal, which would be a confusing side-effect
    return os;
}

assignment operator
Bu sınıfın assignment operator metodu yoktur. Kullanmaya çalışırsak şu hatayı alırız.

function "std::basic_ostream<...>::operator=(const std::basic_ostream<...>::_Myt &) ... cannot be referenced -- it is a deleted >function

clear metodu
Error flag'leri good yapmak için şöyle yaparız.

std::ostream request_stream = ...;
request_stream << "...";
...
request_stream.clear();

getloc metodu
Yeni bir locale + facet yaratmak için şöyle yaparız.

std::locale(std::cout.getloc(), myfacet);

operator void* - C++98
Şöyle yaparız.

ostream m_stream = ...;
if(m_stream != NULL){
  ...
}

operator bool - C++11
Açıklaması şöyle

Before C++11, std::ostream could be implicitly converted to void* via operator void*(), which returns a null pointer if error has occurred on the stream.

Since C++11 the conversion function was changed to explicit operator bool(), which returns false if error has occured. Note the function is declared as explicit, which means implicit conversion to bool is not allowed,

Bu metod aslında şuna eşit.

if (!m_stream.fail()) {
  ...
}

Şöyle yaparız.

if (m_stream) {
  ...
}

Şöyle yaparız.

std::ostream s = ...;
if (!s)
  std::cout << "Failed to open file" << std::endl;

member operator << metodlar
cout için hem member "operator <<" hem de free style "operator <<" metodları var.

Üye "operator <<" metodları tek parametre alıyor. Üye olanların imzaları şöyle.

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

basic_ostream& operator<<( int value );
basic_ostream& operator<<( unsigned int 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<<( float value );
basic_ostream& operator<<( double value );
basic_ostream& operator<<( long double value );

basic_ostream& operator<<( bool value );

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

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

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

Üye metodları çağırmak için şöyle yaparız

cout.operator<<(num);

operator << bool
bool değişkeni stream'e yazar.
Örnek
Şöyle yaparız

bool c = ...;

std::cout << c <<"\n"; //the output is 1

operator << double
double değişkeni stream'e yazar. İmzası şöyle.

basic_ostream<charT, traits>& operator<<(double f);

Örnek
Şöyle yaparız

double a = 12;
cout.operator<<(a);  //works

operator << void *
pointer değişkenin adresini stream'e yazar. member operatörün imzası şöyle.

std::ostream& operator<<( const void* value );

Örnek
Elimizde şöyle bir kod olsun.

struct Foo
{
  int a;
  int b;
  int c;
};

Adresi yazdırmak için static_cast kullanmak gerekir. Şöyle yaparız

printf( "%p\n", &some_foo.c );
std::cout << static_cast<void*>{&some_foo.c} << '\n';

rdbuf metodu
Örnek - redirect stdout to stderr
Şöyle yaparız.

#include <iostream>

int main() {
  std::cout << "to stdout\n";
  std::cout.rdbuf(std::cerr.rdbuf());
  std::cout << "to stderr\n";
}

Diğer - Free Style Metodlar

Free style operator << metodların imzaları şöyle.

operator<<(cout, str);

operator << char

non-member olan bu metodun bir sürü parametre tipi için overload edilmiş hali var. char için imzası şöyle.

std::ostream& operator<<(std::ostream&, char const*);

template olarak düşünürsek char için imzası şöyle.

template <class Traits >
basic_ostream<char,Traits>& operator<<( basic_ostream<char,Traits>& os,
                                        char ch );

operator << - function pointer
Açıklaması şöyle.

Calls func(*this);. These overloads are used to implement output I/O manipulators such as std::endl.

İmzası şöyle.

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