1

Must be honest, I am getting confused between what keywords go in the function (and sometimes data member) declarations in the header file, versus what goes in the implementation file.

What is the set of rules to follow? For example

(Updated per comments)

  • Header files don't contain implementation except if the function is declared as "inline"
  • Data members don't contain a default value, unless if the type is static, const, int/enum (unless C++11)
  • Public/private/protected usually appear in the header file
  • "Static" usually appears in the header file, not the implementation file.

Are thee any other rules I can use to follow? Const?

What about for inheritance? I presume "virtual" only goes in header files? If I inherit virtual functions from Class A into Class B, does the header file of Class B have to declare the virtual functions it overrides? What about a pure virtual function in Class A, when I override in Class B would I have to include the pure virtual function definition in the header file of the derived class?

Improve this question
8
  • Overly broad this one, and your 3'rd and 4'th rule are wrong. Break it down into specifics. Commented Mar 1, 2013 at 13:12
  • A header file should also contain a function implementation if it is a template function. Commented Mar 1, 2013 at 13:12
  • 2
    Nothing has to go in a header. Commented Mar 1, 2013 at 13:12
  • 4
    I think you are approaching the question from the wrong side. It's not about header/implementation files, it's all about declarations/definitions. Sure, in practice declarations often end up in the header and definitions in the .cpp but that's just that: often, there is nothing mandatory about it. You should do some research about declarations, definitions, and compilation units. Commented Mar 1, 2013 at 13:14
  • 1
    Think of it more in terms of how it is compiled... #include effectively pastes the text in the 'header' file into the place where the #include is. After this copy/paste then the whole lot is compiled. Commented Mar 1, 2013 at 13:15

2 Answers 2

Reset to default
2

Looks like you are trying to make some formal rules without understanding how it works. But it is really simple, when preprocessor sees #include directive it just replace it with content of that file (it is like command copy whole file and paste it here). So instead of making formal rules just ask yourself questions: should this statement appear in every .cpp file that uses this header? Will they still compile? Do I really need it everywhere, or it can be in only one .cpp file that provides implementation? If answers are yes, then this statement should go to the header, if no to any of them, then put it into .cpp implementation file.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

1

The #include statement in C and C++ is much simpler than you're giving it credit for: it takes the contents of the include'd file, and dumps it straight into your including file. This can be anything (I see a lot of newbie developers in my line of work. If it's a file on disk, at some point someone's tried to include it): even .cpp files. You can, if you want to prove it to yourself, copy & paste the contents of an included file in place of an include - everything should work as before.

For completeness: once the pre-processor has dumped all the included files to where they are asked for, the compiler compiles each file separately. This typically leaves you with a bunch of declarations with no implementation and a bunch of implementations with no declarations: the linker sorts out these references. So if you ever get a linker error, that means that somewhere you've mis-matched something: maybe you declared something twice, or never implemented it.

What we actually have is a series of best practices about what we want in header files and what we want in source files. Typically, we like to have declarations in a header file. In other words, the header file should tell me (the programmer) what things I expect to find in the implementation. Typically, these are declarations: hence why you generally only see access modifiers (public, private, protected) in headers. Some programmers will do "odd" stuff like writing constructors in header files: this is valid, but is generally not expected - you want your header to tell me what things I can use from your code, not how your code works.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.