Thread: strings in header files

Incidentally...

Originally Posted by brewbuck

Never, ever, ever, EVER put a using directive in a header file. NEVER.

Though never is too strong a word here, since a using directive in an inline function in a header file is acceptable since its effects would be restricted to the scope of the function. On a related note, a using declaration in class scope in a header file may be the correct thing to do if one needs to bring in a name from a base class that is otherwise hidden.

Originally Posted by Aisthesis

I still do have 1 question remaining, emerging mainly from Mario's comment that he likes keeping the #include <iostream>

At least both the books I've been using have up to now NOT put this in in header files. I'm pretty sure they've avoided #include's altogether in headers. There, I could indeed see an exception if you wanted to declare an inline function using cin, cout, or anything else requiring a header.

But if you only have prototypes, struct, class declarations, etc. in there, I'm not seeing why to keep it. The reason I started with it in the first place was the hope that it might get the compiler to accept my string, but the #include didn't really have anything to do with that.

Books usually do that since they assume the reader will include the necessary headers.

You have to undestand that even during declaration the types you use must be known to the compiler. this is only possible through the #include directive.

Now you may be mislead into believe it works without the include. I'll give you an example of an apparent lack of #include that compiles just fine:

Code:

Header file (test.hpp):
struct golf
{
	std::string fullname; //oops?
	int handicap;
};


Source File:
#include <iostream>
#include "test.hpp"

int main() {

 //do nothing

}

This compiles. Despite the lack of #include <string> in the header file, the compiler has no problems finding the std::string type. Why?

Because in reality your source file only includes test.hpp after including <iostream>. Since <iostream> itself includes <string> at some point, it works.

But what happens if you want to use test.hpp somewhere else? You will have to guarantee <string> is included also before "test.hpp". Now, imagine you are grabbing your code in 3 months, or that someone else wants to include "test.hpp". Do you think you will remember then you will need to include <string> on your source file before including "test.hpp"? And what about that other person? Do you think they will even know they need to include <string>?

Originally Posted by Daved

I think Mario knows this but I do want to clarify. <iostream> does not officially include <string>, but with some libraries it appears to work because they share common includes.

Yes, I should have worded it better.

With MSVC 9.0 this is the include path to the actual declaration of std::string, from the original iostream, to xstring where it is finally declared.

iostream
istream
ostream
ios
xlocnum
streambuf
xiosbase
xlocale
stdexcept
xstring

Originally Posted by Aisthesis

hey, if you guys wouldn't mind, take a look at the header file I'm getting ready to post from my html translator problem. It compiles and runs without the #include (and using std::string).

I don't think you are listening. It works because of an almost random event. The std::string name is being introduced by some other header. This is pure coincidence. Try to insert your header file somewhere else where std::string is not being declared by some header file and your code will not work.

Originally Posted by Aisthesis

"Books usually do that since they assume the reader will include the necessary headers."

Not in these cases because these are chapters introducing the way to code multi-file programs. It may be coincidence that the examples they used in these chapters didn't NEED the includes, but they're not omitting them here because it's self-evident. They purport to be providing complete code that works.

Please share us the titles, so we start a new sticky thread on books no one should read.

Originally Posted by Aisthesis

"It works because of an almost random event."

Having the std::string name introduced elsewhere is no coincidence when your header file only includes a prototype that uses it. Thye prototype obviously MUST be elaborated on with a full-scale function definition.

Let's get something straight here. You are NOT declaring a prototype. The only prototypes I know are function prototypes. You are defining a class (or struct, which is a class too). The only thing remotely close to a function prototype that is applied to classes is a class forward declaration. And that is definitely not what you are doing:

Code:

class B; // class forward declaration

class A { // class definition
  /* ... */
};

So with that off your mind, let's proceed...

In any case you could be declaring a function and you could be declaring the prototype of a function and you would still be forced to #include the necessary headers for those function arguments or return type:

Code:

void myfunc (std::string str); // function declaration, or prototype if you must

The above function declaration will NOT compile if the std::string identifier is not being declared somewhere in your includes path. Create a new project and try this:

Code:

void myfunc (std::string str);

int main() {
    // do nothing
}

void myfunc (std::string str) {
    // do nothing
}

It will fail to compile.

Originally Posted by Aisthesis

"The std::string name is being introduced by some other header."

It can't be. That's the only header file in the program.

Please show us your code. Mention also which compiler you are using.

Try this... In your .cpp file, you must be doing something like this:

Code:

#include <string>
#include "Your_Header.h"
...

So try switching the #include statements around so that you include your header file before any of the standard header files. Compile it and watch the errors you get.
Now add #include <string> back into your header file and see if those errors disappear.