arguement for file as well as console output

If you want to maintain the same interface, you can make a fake stream (a class that support the << operator like a stream) that redirect the output.

Something like

class dupstream
{
    std::ostream *s1, *s2;
    dupstream(comnst dupstream&);
    dupstream& operator=(comnst dupstream&);
public:
    dupstream(std::ostream& a, std::ostream& b)
        :s1(&a), s2(&b)
    {}
    template<class T>
    friend dupstream& operator<<(dupstream& s, const T& a)
    {
        *s1 << a;
        *s2 << a;
        return s;
    }
};

and then use it as

ofstream fout;
fout.open("D:\\Output.txt");
dupstream(std::cout, fout);

dupstream << "Value of x="<<x<<endl;
dupstream << "Value of y="<<y<<endl;
dupstream << "Value of z="<<z<<endl;

If you want to pass an output stream as function argument you could do that like so:

void myfunction(ostream& outs)
{
	outs << "hello";
}

Henry Minute's way seems like the nicer solution however.

The simple answer is to use a unix tee like utlility for windows.

The tee command reads standard input, then writes its content to standard output and simultaneously copies it into the specified file.

Here is one with source code:
http://www.chipstips.com/?p=129[^]

Regards
Espen Harlinn

Thanks for your replies. Here is the code I've rewritten:

#include<iostream>
#include<fstream>
#include<conio.h>

using namespace std;
void display( std::ostream & output_to )
{
    output_to << "I'm some output" << std::endl;

    // Add more lines to taste...
}
int main()
{
	ofstream fout;
	fout.open("D:\\sampleout.txt");

	display(cout);
	dispaly(fout);

	_getch();
}

and that shows a compile error(VC++ 2008 Express Edition) error C3861: 'dispaly': identifier not found.

Turning the question around a bit, what's common between std::cout and an arbitrary std::ofstream?

If you have a look at the documentation for both you'll see that they're instances of classes derived from std::ostream. In your examples all the operations you do are members of std::ostream so yep, there is a parameter type you can use which will do what you want - a reference to a std::ostream. So you could write:

void display_some_guff( std::ostream &output_to )
{
    output_to << "I'm some output" << std::endl;

    // Add more lines to taste...
}

and then feed the function either std::cout or a std::ofstream.

So now you know how (okay, you know one way) to abstract out the thing you want to do the output to. However are you sure you're concentrating on abstracting out the right thing? If what you were interested in displaying was neatly parceled up in an object your code becomes:

std::cout   << prog_state << std::endl;
file_stream << prog_state << std::endl;

and the whole question goes away or becomes a lot less pressing as you've solved it as a direct consequence of your object model.

Cheers,

Ash