Basic question on streams

[John Simeon]

I understand that to creat a file output stream for example, I have to
include <fstreamand then:

ofstream fout;

which will create an object of type ofstream that I can use to interact with
a file.

My question concerns cout and cin. Clearly by intuition, these are also
objects? Is it possible to define an object of the same type of cin and cout
and use them similarly? What are those types and what would the definitions
to create those objects look like?

Thanks.

--
Posted via a free Usenet account from http://www.teranews.com

[Gianni Mariani]

John Simeon wrote:

I understand that to creat a file output stream for example, I have to
include <fstreamand then:

ofstream fout;

which will create an object of type ofstream that I can use to interact with
a file.

My question concerns cout and cin. Clearly by intuition, these are also
objects? Is it possible to define an object of the same type of cin and cout
and use them similarly? What are those types and what would the definitions
to create those objects look like?

Look up the class hierarchy for std::ostream. You'll see that ofstream
derives from ostream hence cout is interchangeable with your fout.

[Jim Langston]

"John Simeon" <jo******@gmail .comwrote in message
news:46******** **************@ free.teranews.c om...

>I understand that to creat a file output stream for example, I have to
include <fstreamand then:

ofstream fout;

which will create an object of type ofstream that I can use to interact
with a file.

My question concerns cout and cin. Clearly by intuition, these are also
objects? Is it possible to define an object of the same type of cin and
cout and use them similarly? What are those types and what would the
definitions to create those objects look like?

The definition to create a cin or cout duplicate would be fairly complicated
because you have to talk to the console, however that is done on the OS
level. Like for windows I'd have to attach the console window, send the
output, etc...

However.

cin derives from istream, cout derives from ostream and can be used as such.

Here is a little sample toy program to illistrate how you can use std::cout
as a std::ostream:

#include <iostream>
#include <ostream>
#include <fstream>
#include <string>

void OutputRhyme( std::ostream& Output )
{
Output << "Mary had a little lamb\n"
"Its fleece was white as snow.\n"
"Every where that Mary went\n"
"The lamb was sure to go\n";
}

int main()
{
std::string Choice = "";
while ( Choice != "Q" )
{
while ( Choice != "F" && Choice != "S" && Choice != "Q" )
{
std::cout << "Output to <F>ile or <S>creen. <Qto Quit: ";
std::getline( std::cin, Choice );
}

if ( Choice != "Q" )
{
if ( Choice == "F" )
{
std::ofstream File("Rhyme.txt ");
OutputRhyme( File );
}
else
OutputRhyme( std::cout );
Choice = "";

}
}

}

[John Simeon]

Wait, are you basically saying that ofstream inherits from ostream and that,
therefore, it should be possible to output to the screen with fout?

How would I do that if so?
"Gianni Mariani" <gi*******@mari ani.wswrote in message
news:46******** *************** @per-qv1-newsreader-01.iinet.net.au ...

John Simeon wrote:

>I understand that to creat a file output stream for example, I have to
include <fstreamand then:

ofstream fout;

which will create an object of type ofstream that I can use to interact
with a file.

My question concerns cout and cin. Clearly by intuition, these are also
objects? Is it possible to define an object of the same type of cin and
cout and use them similarly? What are those types and what would the
definitions to create those objects look like?

Look up the class hierarchy for std::ostream. You'll see that ofstream
derives from ostream hence cout is interchangeable with your fout.

--
Posted via a free Usenet account from http://www.teranews.com

[BobR]

John Simeon <jo******@gmail .comwrote in message...

I take it your statement on the task "not being for beginners" is in
reference to creating a cout or cin look-alike from scratch.

I however would merely like to declare a type of the same opject and use

it

that way.

Would this be appropriate then:

ostream Output;

Output << "Hello World!"

That depends on how you declared/defined 'ostream'. Did you define
'operator<<()'?

Please do not top-post.

Why not just use the standard libraries:

#include <iostream>
#include <sstream>
#include <string>
std::ostringstr eam Output;

void MyFunc(){
Output << " In MyFunc()!";
return;
}

int main(){
Output << "Hello World!";
// ......
std::cout<< Output.str() <<std::endl;
Output.clear(); Output.str("");
Output << " How are you?";
MyFunc();
std::string TheOutput( Output.str() );
std::cout<< TheOutput <<std::endl;
// ......
std::cout<< Output.str() <<std::endl;
return 0;
} // main()

--
Bob R
POVrookie

[Gianni Mariani]

John Simeon wrote:

Wait, are you basically saying that ofstream inherits from ostream and that,
therefore, it should be possible to output to the screen with fout?

How would I do that if so?

Open the screen "file".

That is platform specific.

If you want to create your own ostream type that writes to a file and
the screen, you can do that too.

G

[Robert Bauck Hamar]

John Simeon wrote:

Wait, are you basically saying that ofstream inherits from ostream and
that, therefore, it should be possible to output to the screen with fout?

No, he's saying that a std::ostream and a std::ofstream has the same
functions for output, and a std::ofstream can be used in situations where a
std::ostream is expected.

How would I do that if so?

Your first problem is: define screen. C++ has no concept of screens. C++
guarantees that there exists a standard out, but does not say where it ends
and how. On many computers, the screen is a buffer in memory, and writing
to special addresses will make characters appear on the screen. On other
systems, the screen can only be reached with special system calls. How it
works on your system, however is not the topic of this group. But here is
something that works on my system:

std::ofstream out("/dev/stdout");
out << "Hello, world\n";

This works on UNIX systems, where /dev/stdout is a special file. I don't
know if it works, but somethings tell me that the special file name CON has
similar meanings on WinDOS.

--
rbh

[Jim Langston]

"Robert Bauck Hamar" <ro**********@i fi.uio.nowrote in message
news:f8******** **@readme.uio.n o...

John Simeon wrote:

>Wait, are you basically saying that ofstream inherits from ostream and
that, therefore, it should be possible to output to the screen with fout?

No, he's saying that a std::ostream and a std::ofstream has the same
functions for output, and a std::ofstream can be used in situations where
a
std::ostream is expected.

>How would I do that if so?

Your first problem is: define screen. C++ has no concept of screens. C++
guarantees that there exists a standard out, but does not say where it
ends
and how. On many computers, the screen is a buffer in memory, and writing
to special addresses will make characters appear on the screen. On other
systems, the screen can only be reached with special system calls. How it
works on your system, however is not the topic of this group. But here is
something that works on my system:

std::ofstream out("/dev/stdout");
out << "Hello, world\n";

This works on UNIX systems, where /dev/stdout is a special file. I don't
know if it works, but somethings tell me that the special file name CON
has
similar meanings on WinDOS.

It's actually CON: The following program outputs:

Did it work?
Testing

#include <iostream>
#include <fstream>
#include <string>

int main()
{
std::ofstream Console("CON:") ;
Console << "Testing\n" ;
std::cout << "Did it work?\n";

return 0;
}

One would expect
Testing
Did it work?
but that's not what was output.

[James Kanze]

On Jul 23, 3:54 am, Robert Bauck Hamar <roberth+n...@i fi.uio.no>
wrote:

John Simeon wrote:

Wait, are you basically saying that ofstream inherits from ostream and
that, therefore, it should be possible to output to the screen with fout?

No, he's saying that a std::ostream and a std::ofstream has the same
functions for output, and a std::ofstream can be used in situations where a
std::ostream is expected.

How would I do that if so?

Your first problem is: define screen. C++ has no concept of screens. C++
guarantees that there exists a standard out, but does not say where it ends
and how. On many computers, the screen is a buffer in memory, and writing
to special addresses will make characters appear on the screen. On other
systems, the screen can only be reached with special system calls. How it
works on your system, however is not the topic of this group. But here is
something that works on my system:

std::ofstream out("/dev/stdout");
out << "Hello, world\n";

This works on UNIX systems, where /dev/stdout is a special file. I don't
know if it works, but somethings tell me that the special file name CON has
similar meanings on WinDOS.

--
rbh

[James Kanze]

On Jul 23, 3:54 am, Robert Bauck Hamar <roberth+n...@i fi.uio.no>
wrote:

John Simeon wrote:

Wait, are you basically saying that ofstream inherits from ostream and
that, therefore, it should be possible to output to the screen with fout?

No, he's saying that a std::ostream and a std::ofstream has
the same functions for output, and a std::ofstream can be used
in situations where a std::ostream is expected.

More generally, except when actually opening or closing the
file, you should use std::ostream&, and not std::ofstream&.

How would I do that if so?

Your first problem is: define screen. C++ has no concept of screens. C++
guarantees that there exists a standard out, but does not say where it ends
and how. On many computers, the screen is a buffer in memory, and writing
to special addresses will make characters appear on the screen. On other
systems, the screen can only be reached with special system calls. How it
works on your system, however is not the topic of this group. But here is
something that works on my system:

std::ofstream out("/dev/stdout");
out << "Hello, world\n";

That's not standard Unix (which only requires "/dev/tty",
"/dev/null" and "/dev/console"), just a common extension. And
even on systems where it's implemented (e.g. Solaris or Linux),
it doesn't write to the screen; it writes to where ever standard
out happens to be redirected.

In general, to write to the screen, you need to use the X
Windows interfaces. "/dev/tty" will output to the terminal
window your process is connected to, IF it is connected to a
terminal window, and "/dev/console" will output to the console
window(s), if there are any.

This works on UNIX systems, where /dev/stdout is a special file. I don't
know if it works, but somethings tell me that the special file name CON has
similar meanings on WinDOS.

I'm not sure about the name, but there is something similar to
"/dev/tty" under Windows, I think.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]