Re: which headers to #include - std::ostream std::iostream std::iosfwd

From:

Saeed Amrollahi <amrollahi.saeed@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Fri, 12 Nov 2010 23:31:07 -0800 (PST)

Message-ID:

<2be4014c-d401-4e5b-9c1e-af0a9d097e79@o29g2000vbi.googlegroups.com>

On Nov 13, 7:05 am, "subramanian10...@yahoo.com, India"
<subramanian10...@yahoo.com> wrote:

Suppose I have a program which uses 'ostream' type as the parameter
type for a function and 'cout' object for writing into the standard
output. Following is my understanding regarding, which headers to
#include for this scenario.

Since the program uses 'cout' object, I have to #include <iostream>
header for 'cout'. In the ISO/IEC-14882:2003 document, in page 608, in
section 27.3 - Standard iostream objects, the synopsis for the header
<iostream> mentions the following line(apart from other statements):
     extern ostream cout;
From the above statement, since 'cout' is mentioned for <iostream>,
#including <iostream> is sufficient for using 'cout' object in my
program. Moreover, since 'ostream' is also mentioned in the same
statement, the forward declaraion of 'ostream' type should also be
known in the <iostream> header. This means that I need NOT #include
<iosfwd>. Is this
correct ? Since the class definition of the type 'ostream' is
needed(because the function parameter type is 'ostream&'), I HAVE to
#include <ostream> header instead of relying on the particular
compiler implementation #including the <ostream> inside <iostream>.
So, for the scenario mentioned in the beginning, I need ONLY to
#include
    #include <iostream>
    #include <ostream>
    // ...
    using namespace std;

I have NOT #included <iosfwd> header.

Is the above understanding of mine is correct ?
Correct me wherever I am wrong.

Kindly explain.

Thanks
V.Subramanian

Hi
I think your understanding in general is correct.
If you want to use the standard narrow and wide
iostream objects you have to include <iostream>.
It's the reason, why the the typical "hello, world" program
is like this:

#include <iostream>
int main()
{
  using namespace std;
  cout << "Hello, world\n";
  return 0;
}

If you want use just output stream facilities, you can
include just <ostream>. Similarly, if you
want use just output stream facilities, you can
include just <istream>.
consider:

#include <istream>
struct istream_wrapper
{
istream_wrapper(std::istream& is_) : is(is_) {}
  std::istream& is;
};

#include <ostream>
struct ostream_wrapper
{
  ostream_wrapper(std::ostream& os_) : os(os_) {}
  std::ostream& os;
};

#include <iostream> // you have to include this
int main()
{
  using namespace std;
  istream_wrapper iw(cin);
  ostream_wrapper ow(cout);
  int i;
  iw.is >> i;
  ow.os << i << '\n';

  return 0;
}

In above example, we just use istream and ostream references.
In this case, we can include the forward declaration of these
classes, So if you include just <iosfwd>, it's OK.

#include <iosfwd>
struct istream_wrapper
{
istream_wrapper(std::istream& is_) : is(is_) {}
  std::istream& is;
};

struct ostream_wrapper
{
  ostream_wrapper(std::ostream& os_) : os(os_) {}
  std::ostream& os;
};
// same as before

There are some good points in Herb Sutter's Weblog. For instance
please see the following:
     http://www.gotw.ca/gotw/007.htm

HTH
  -- Saeed Amrollahi