Check if ostream object is cout or ofstream, c++

Question

Is there a way in C++ to check if an ostream object is cout or a ofstream object?

Something like:

ostream& output(ostream& out)
{
    if (out == cout)
        return out;
    else
    {
        out << "something different because its not going to the console" << endl;
        return out;
    }
}

The reason I want to do this, is that I want to overload the << operator to do two different things depending on what type of stream it is used with.

Is it possible to just overload the << operator twice each time with a different type of stream?

Updated to reflect intention better.

Answer 1

It's possible by checking the stream's 'identity': if ( &out == &cout ) ....

However, I'm in doubt on the usefullness of this test. If your function can handle any output stream, why bother about what stream it is using?

Answer 2

You will definitely get further by checking the streambuffer identity

if (s.rdbuf() == std::cout.rdbuf())

This is because it is trivially simple to cross-assign / alias streams to buffers, see http://www.cplusplus.com/reference/iostream/ios/rdbuf/ and the Josuttis book

Answer 3

It sounds like what you really want to know is not whether the stream is cout but whether the underlying file descriptor is attached to a terminal? If that is so, you need the underlying file descriptor. Unfortunately, you can't get that from a iostream. If it's possible to use cstdio instead of iostream, then you can. If you do have the file descriptor, determining if you are writing to a terminal is a simple as seeing if tcgetattr() returns -1.

Also, don't let anyone tell you not do implement some functionality that you need because it tarnishes the purity of some leaky abstraction. If you really need different behavior, then do what you need to do to produce that functionality.

Answer 4

I consider changing how you stream based on the object you are streaming to do be a horrible idea that completely ignores the whole point of how the stream objects are intended to work. So, I would create a member class or function which returns an object of a type that handles the stream differently. So, for example, if you wanted to provide a colorized stream, you would call:

std::cout << myclass.colorstreamer << endl;

Edit:

Your proposal for handling streams is a bad idea because you have no clue how other people are going to use your code. It is completely unintuitive for a stream to behave differently depending on what object is doing the streaming. I liken this to having a function which returns a different result depending on who called it rather than dependent on what its arguments are, though I acknowledge that technically the stream is an argument.

As for how to do it this way, one way would be to create a colorstreamer, make this new class a member of myclass and make myclass a member of colorstreamer, then make colorstreamer's stream operator a friend of myclass. I'm more worried about the semantics of calling the function (i.e. using .colorstreamer to control how it streams rather than using the stream itself) than I am about how to implement it. My suggestion for how to implement it is quite possibly a bad way to do it; my C++ is rusty.