Class Inheritance over multiple source files

I need to get several classes to inherit from one another, but for the sake of organisation in the project I'm working on at the moment, I want to have them in different source code files.

At the moment, I am doing it like this:

Code:

---

/* Contents of foo.h */

class Foo
{
          private:

          public:
                    void func(char *cstring);

};


/* Contents of bar.h */

#include "foo.h"

class Bar : public Foo
{
          private:

          public:
                /* Methods */

};

---

But, efficiency is a big part of the program I am writing, I want to get maximum efficiency, and so I was wondering, if I do it like this, won't the file foo.h in the example get compiled over and over again? since I have about 8 or 9 other header files getting compiled off one header file which contains this "super class", lol.

I was wondering if there was a better way of doing it to get more efficient code. also, is my program stucture the best one to use?

I would be included over and over, yes... The only way to avoid that is to use a forward-declaration where you can.
The you need to include those files so that the compiler can see the classes it is deriving from.

If you've got anything in foo.h that actually gets compiled, then it's broken (multiple symbol definitions or whatever). #include just reads the file and dumps it in.

Quote:

---

Originally Posted by Elysia

I would be included over and over, yes... The only way to avoid that is to use a forward-declaration where you can.

---

You think that I should include the class declaration in the main cpp file before the other headers are included?

Thanks for being so quick btw, lol.

edit: Likewise tabstop

Did not say that. It is bad practice to have headers relying on other headers without including them.
What I meant is that if your other headers refer to the your super-header, but does not actually use it, you can use a forward-declaration.

Including it in every source file won't have any effect on the speed of the program, only on the speed of compilation...

Also, if you have correct include guards in your header files, including the same file multiple times will not affect the compile time (much [1]) as there will only ever be one copy of the actual contents of the header file.

[1] I believe most compilers (technically, the preprocessor part of the compiler) actually DETECT the fact that a certain header file has a include guard, and if it's been included already, don't include it again. That way, there's extremely little overhead of having the same header file(s) included multiple times.

--
Mats

That doesn't apply to multiple compilation units, though.

And the most prominent of those that don't detect this is MSVC++.