As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance. If this question can be reworded to fit the rules in the help center, please edit the question.

it is a common OOP paradigm,.h is a class declaration and cpp being the definition.One does not need to know how it is implemented,he/she should only know the interface.
– Manish KakatiApr 26 '17 at 11:29

This is the best part of c++ separating interface from implementation. It's always good rather than keeping all the code in the single file, we have interface separated. Some amount of code are always there like inline function which are part of header files. Looks good when a header file is seen displays the list of functions declared and class variables.
– MiankJun 7 '17 at 5:35

9 Answers
9

Well, the main reason would be for separating the interface from the implementation. The header declares "what" a class (or whatever is being implemented) will do, while the cpp file defines "how" it will perform those features.

This reduces dependencies so that code that uses the header doesn't necessarily need to know all the details of the implementation and any other classes/headers needed only for that. This will reduce compilation times and also the amount of recompilation needed when something in the implementation changes.

It's not perfect, and you would usually resort to techniques like the Pimpl Idiom to properly separate interface and implementation, but it's a good start.

Not really true. The header still contains a major part of the implementation. Since when were private instance variables part of a class's interface? Private member functions? Then what the hell are they doing in the publicly visible header? And it falls further apart with templates.
– jalfDec 2 '08 at 18:13

10

That's why I said that it's not perfect, and the Pimpl idiom is needed for more separation. Templates are a whole different can of worms - even if the "exports" keyword was fully supported in most compilers it would still me syntactic sugar rather than real separation.
– Joris TimmermansDec 3 '08 at 8:17

2

How do other languages handle this? for example - Java? There is no header file concept in Java.
– LazerJun 13 '10 at 12:18

7

@Lazer: Java is simpler to parse. The Java compiler can parse a file without knowing all the classes in other files, and check the types later. In C++ lots of constructs are ambiguous without type information, so the C++ compiler needs information about referenced types to parse a file. That's why it need headers.
– NikiJul 28 '10 at 19:06

11

@nikie: What does "ease" of parsing have to do with it? If Java had a grammar that was at least as complex as C++, it could still just use java files. In either case, what about C? C is easy to parse, yet uses both headers and c files.
– Thomas EdingDec 2 '11 at 21:18

C++ compilation

A compilation in C++ is done in 2 major phases:

The first is the compilation of "source" text files into binary "object" files: The CPP file is the compiled file and is compiled without any knowledge about the other CPP files (or even libraries), unless fed to it through raw declaration or header inclusion. The CPP file is usually compiled into a .OBJ or a .O "object" file.

The second is the linking together of all the "object" files, and thus, the creation of the final binary file (either a library or an executable).

Where does the HPP fit in all this process?

A poor lonesome CPP file...

The compilation of each CPP file is independent from all other CPP files, which means that if A.CPP needs a symbol defined in B.CPP, like:

Then, if you have C.CPP which uses the same symbol, you then copy/paste the declaration...

COPY/PASTE ALERT!

Yes, there is a problem. Copy/pastes are dangerous, and difficult to maintain. Which means that it would be cool if we had some way to NOT copy/paste, and still declare the symbol... How can we do it? By the include of some text file, which is commonly suffixed by .h, .hxx, .h++ or, my preferred for C++ files, .hpp:

One small thing - why include B.HPP in B.CPP?

In the current case, this is not needed, and B.HPP has the doSomethingElse function declaration, and B.CPP has the doSomethingElse function definition (which is, by itself a declaration). But in a more general case, where B.HPP is used for declarations (and inline code), there could be no corresponding definition (for example, enums, plain structs, etc.), so the include could be needed if B.CPP uses those declaration from B.HPP. All in all, it is "good taste" for a source to include by default its header.

Conclusion

The header file is thus necessary, because the C++ compiler is unable to search for symbol declarations alone, and thus, you must help it by including those declarations.

One last word: You should put header guards around the content of your HPP files, to be sure multiple inclusions won't break anything, but all in all, I believe the main reason for existence of HPP files is explained above.

@nimcap : You still have to copy paste the signature from header file to cpp file, don't you? : No need. As long as the CPP "includes" the HPP, the precompiler will automatically do the copy-paste of the contents of the HPP file into the CPP file. I updated the answer to clarify that.
– paercebalJun 18 '12 at 8:47

6

@Bob : While compiling A.cpp, compiler knows the types of arguments and return value of doSomethingElse from the call itself. No, it doesn't. It does only know the types provided by the user, which will, half the time, won't even bother to read the return value. Then, implicit conversions happen. And then, when you have the code: foo(bar), you can't even be sure foo is a function. So the compiler has to have access to the information in the headers to decide if the source compiles correctly, or not... Then, once the code is compiled, the linker will just link together functions calls.
– paercebalJan 7 '13 at 8:48

2

@Bob : [continuing] ... Now, the linker could do the work done by the compiler, I guess, which would then make your option possible. (I guess this is the subject of the "modules" proposition for the next standard). Seems, they're just a pretty ugly arbitrary design. : If C++ had been created in 2012, indeed. But remember C++ was built upon C in the 1980s, and at that time, constraints were quite different at that time (IIRC, it was decided for adoption purposes to keep the same linkers than C's).
– paercebalJan 7 '13 at 8:53

1

@paercebal Thanks for explanation and notes, paercebal! Why can't I be sure, that foo(bar) is a function - if it's obtained as a pointer? In fact, speaking of bad design, I blame C, not C++. I really don't like some constraints of pure C, such as having header files or having functions return one and only one value, while taking multiple arguments on input (doesn't it feel natural to have input and output behave in a similar manner; why multiple arguments, but single output?) :)
– Boris BurkovJan 8 '13 at 17:20

1

@Bobo : Why can't I be sure, that foo(bar) is a function : foo could be a type, so you would have a class constructor called. In fact, speaking of bad design, I blame C, not C++ : I can blame C for a lot of things, but having been designed in the 70's won't be one of them. Again, constraints of that time... such as having header files or having functions return one and only one value : Tuples can help mitigate that, as well as passing arguments by reference. Now, what would be the syntax to retrieve returned multiple values, and would it be worth it to change the language?
– paercebalJan 9 '13 at 10:23

Because C, where the concept originated, is 30 years old, and back then, it was the only viable way to link together code from multiple files.

Today, it's an awful hack which totally destroys compilation time in C++, causes countless needless dependencies (because class definitions in a header file expose too much information about the implementation), and so on.

Because the people who designed the library format didn't want to "waste" space for rarely used information like C preprocessor macros and function declarations.

Since you need that info to tell your compiler "this function is available later when the linker is doing its job", they had to come up with a second file where this shared information could be stored.

Most languages after C/C++ store this information in the output (Java bytecode, for example) or they don't use a precompiled format at all, get always distributed in source form and compile on the fly (Python, Perl).

@ShuvoSarker because as thousands of languages have demonstrated, there is no technical explanation for C++ making programmers write function signatures twice. The answer to "why?" is "history".
– BorisFeb 12 at 17:16

It's the preprocessor way of declaring interfaces. You put the interface (method declarations) into the header file, and the implementation into the cpp. Applications using your library only need to know the interface, which they can access through #include.

Often you will want to have a definition of an interface without having to ship the entire code. For example, if you have a shared library, you would ship a header file with it which defines all the functions and symbols used in the shared library. Without header files, you would need to ship the source.

Within a single project, header files are used, IMHO, for at least two purposes:

Clarity, that is, by keeping the interfaces separate from the implementation, it is easier to read the code

Compile time. By using only the interface where possible, instead of the full implementation, the compile time can be reduced because the compiler can simply make a reference to the interface instead of having to parse the actual code (which, idealy, would only need to be done a single time).

I think its irrelevant if the header file is generated or hand written, the question wasn't "why do people write header files themselves?", it was "why do we have header files". The same goes for preprocessor free headers. Sure, this would be faster.
– DanDec 2 '08 at 13:53

This reduces dependencies so that code that uses the header doesn't
necessarily need to know all the details of the implementation and any
other classes/headers needed only for that. This will reduce
compilation times, and also the amount of recompilation needed when
something in the implementation changes.