Why is the purpose of header files in c programming?

Answer 1

Header files allow programmers to separate interfaces from implementations. Typically, a header file contains the declaration of a single class or a group of related classes or functions, or both. The definitions are typically placed in a corresponding source file (which must include the header), although inline functions are often defined in the header itself, while incomplete types such as template classes and template functions must always be defined in the header.

Although you could place all your code in a single file, header files make it easier to re-use common functions and classes from other programs. You can also build libraries of common classes and functions, each of which requires a header (the interface) that must be included in your source in order for your programs to be able to link to those libraries. Thus headers are an aid to modularisation and re-usability, thereby reducing the need to write duplicate code.

Answer 2

The purpose of header files is to permit the separation of the declaration of functions from the implementation of those functions. Source code that requires forward declarations of those functions do not require the implementation, only the prototype. So rather than type those prototypes in full every time they are required, including the required header file achieves the same end -- just as if you'd typed them in full at the point of inclusion.

Answer 3

Before we can use a name we must first declare it. Built-in names such as int and float do not need to be declared (they are part of the language), but user-defined type definitions, structures, unions, enums and functions must all be declared. This is important because the compiler needs to know the precise memory layout associated with a given name and which operations apply to that name in order to generate the appropriate machine code. If we use a name that the compiler knows nothing about, then the compilation cannot proceed.

It's best to think of each source file as being a translation unit. These are the units that a compiler actually works with and it can only "see" one translation unit at a time. Thus every source file must include declarations for every name that it uses. However, when we use multiple source files, there may be some names that are used by more than one translation unit, thus each name's declaration has to be duplicated in every source file that uses that name. Writing duplicate code by hand is never a good thing because if we make changes to one version of the code then we must repeat those changes across all duplicates. Aside from the additional maintenance cost in editing the same code more than once, it can lead to inconsistencies in our code.

To ensure consistency across all translation units we place our shared declarations in header files. Thus if we need to change a declaration we only need to do it once. In the case of a function declaration we must also update the definition of that function because definitions are also declarations. However, by placing declarations and definitions in corresponding files with a '.h' and '.c' extension respectively, we can easily locate both.

Headers can be included in other headers as well as translation units. When we include a header in another file, the precompiler will replace the #include directive with the content of the specified file, just as if we'd written it out by hand.

Answer 4

Header files ensure declarations are consistent across all translation units that require them. That is, we make the declaration once in a header file, and then include that header in every translation unit that requires it. Typically, a header file contains several closely-related declarations that are intended to be used together. Including a single header not only ensures consistency, it greatly reduces the amount of duplicate code we must write.

Headers may also include definitions, but these must be declared inline otherwise they will be treated as separate entities in each translation unit that uses them. While ideal for small functions where inline expansion is desirable, it is best to avoid declaring variables in header files. Indeed, we should avoid global variables wherever possible as they create maintenance problems (it can be difficult to see where those variables are used) as well as race conditions in multi-threaded applications because global data is shared by all threads. Variables should always be as localised as possible and, where data must be shared between threads, always ensure every thread works with a local copy of the data to minimise the need for synchronisation locks.

Answer 5

To separate the declarations from the definitions.