Why do I need to include both the iostream and fstream headers to open a file

#include <iostream>
#include <fstream>
using namespace std;

int main () {
  ofstream myfile;
  myfile.open ("test.txt");
  return 0;
}

fstream is derived from iostream, why should we include both in the code above?

I removed fstream, however, there is an error with ofstream. My question is ofs开发者_JAVA百科tream is derived from ostream, why fstream is needed to make it compile?

You need to include fstream because that's where the definition of the ofstream class is.

You've kind of got this backwards: since ofstream derives from ostream, the fstream header includes the iostream header, so you could leave out iostream and it would still compile. But you can't leave out fstream because then you don't have a definition for ofstream.

Think about it this way. If I put this in a.h:

class A {
  public:
    A();
    foo();
};

And then I make a class that derives from A in b.h:

#include <a.h>

class B : public A {
  public:
    B();
    bar();
};

And then I want to write this program:

int main()
{
  B b;
  b.bar();

  return 0;
}

Which file would I have to include? b.h obviously. How could I include only a.h and expect to have a definition for B?

Remember that in C and C++, include is literal. It literally pastes the contents of the included file where the include statement was. It's not like a higher-level statement of "give me everything in this family of classes".

std::ofstream is defined in the <fstream> standard library header.

You need to include that header for its definition so that you can instantiate it.

The typedef ofstream and its associated class template are defined by #include <fstream> , so you need that header.

For your actual program, #include <iostream> is not needed. But you may wish to use your fstream object with some functions which operate on ostream or istreams .

Those functions are not defined by #include <fstream> and you need to include the right header for any functions you do use. Some implementations might cause #include <fstream> to also include <iostream> but this is not guaranteed by the C++ Standard.

For example, this code:

ofstream myfile;
myfile.open ("test.txt");

myfile << 1;

requires #include <ostream> (or , since C++11, #include <iostream> which is guaranteed to bring in #include <ostream>).