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.

Johnettajohnette

Relevant: #367455 – Party

What is your motivation for doing this? It seems like a really bad idea to me. – Festus

@Brian: I added above, that I want to use the << operator to do two different things depending on the stream, alternative approaches are welcomed – Johnettajohnette

@Jordan: Yes, I know that you want to use the << to do two different things depending on the stream. Why do you want to do this? It seems like a really bad idea to me. – Festus

The whole point of using streams is to make it anonymous for the destination so everything looks the same no matter what type stream you are using. What happens if somebody connects a file stream to file descriptor 2 (the standard out on most systems). This would be a totally different stream but to the OS it will be going to a console. Alternatively what if the OS hooked up the std::cout to a file, this is so far out of the application space that it would be undetectable inside the application. – Douce

It sounds like your real question might be "how do I detect if output is to a terminal"? – Koreykorff

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?

Stressful

Why? Maybe, to write one thing to a file and a different thing to a terminal. E.g., use escape sequences to colorize output when writing to a terminal. Though it won't work if STDOUT is redirected. – Avram

Thats unlikely to work all the time. You should cast objects to the same type before taking their address (In this case some form of common base stream type). – Douce

@Martin York: is that the case for single-inheritance trees, too? – Stressful

@sehe: I didn't know that. What can you do in that case? – Stressful

@sehe: btw, what is an aliased stream buffer? (cfr #5296984) – Stressful

I meant rdbuf() sharing/aliasing: see my own earlier answer #3319214 – Amateur

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

Amateur

So this is what I lightly termed 'aliasing' a stream buffer. I guess that wasn't too clear, so I have edited my comments to be clearer. – Amateur

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.

Lott

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.

Festus

Could you please elaborate a little more on why it is a bad idea and could you be more specific as to how to approach the problem your way? – Johnettajohnette

@Jordan: Edited to answer your questions, though I think Martin York's comment on your question (i.e. "The whole point of using streams...") is a better wording for why it is a bad idea. – Festus