Thread: Need help understanding Header Files

http://en.wikipedia.org/wiki/Header_file

The point is that the compiler needs to see a class definition or function prototype before using the class/calling the function to make sure it generates correct code and catch errors for you.
So for every .cpp file that needs to use the class/function, it needs the class definition or function prototype. So to avoid copying it and pasting it everywhere, you put that in a header file and include it in all .cpp files.

Originally Posted by Kaidao

Thanks, but I've already tried that site, and I don't know why, I'm in China, and it seems like they have something against Wikipedia. Because no matter where I go in wikipedia, I can't connect...

Well, since I've already given the attribution, I hope they don't mind a copy-and-paste.

In computer programming, particularly in the C and C++ programming languages, a header file or include file is a file, usually in the form of source code, that is automatically included in another source file by the compiler. Typically, header files are included via compiler directives at the beginning (or head) of the other source file.

A header file commonly contains forward declarations of subroutines, variables, and other identifiers. Identifiers that need to be declared in more than one source file can be placed in one header file, which is then included whenever its contents are required.

In the C and C++ programming languages, standard library functions are traditionally declared in header files; see C standard library and C++ standard library for examples.

Motivation

In most modern computer programming languages, programs can be broken up into smaller components such as subroutines, and those components can be distributed among many physical source files, which are compiled separately. Once a subroutine needs to be used somewhere other than where it's defined, the concept of forward declarations or function prototypes must be introduced. For example, a function defined in this way in one source file:

Code:

int add(int a, int b)
{
    return a + b;
}

may be declared (with a function prototype) and then referred to in a second source file, thus:

Code:

extern int add(int, int);
 
int triple(int x)
{
    return add(x, add(x, x));
}

However, this simplistic approach requires that the programmer maintain the function declaration for add in two places — in the file containing its implementation and in the file where it's used. If the definition of the function ever changes, the programmer must remember to update all the prototypes scattered across the program, as well.

Header files provide the solution. A module's header file declares each function, object, and data type that is part of the public interface of the module — for example, in this case the header file would include only the declaration of add. Each source file that refers to add uses the #include directive to bring in the header file:

Code:

/* File add.h */
#ifndef ADD_H
#define ADD_H
 
int add(int, int);
 
#endif /* ADD_H */

/* File triple.c */
#include "add.h"
 
int triple(int x)
{
    return add(x, add(x, x));
}

This reduces the maintenance burden: when a definition is changed, only a single copy of the declaration must be updated (the one in the header file). The header file may also be included in the source file that contains the corresponding definitions, giving the compiler an opportunity to check the declaration and the definition for consistency.

Code:

/* File add.c */
#include "add.h"
 
int add(int a, int b)
{
    return a + b;
}

Typically, header files are used to specify only interfaces, and usually provide at least a small amount of documentation explaining how to use the components declared in the file. As in this example, the implementations of subroutines are left in a separate source file, which continues to be compiled separately. (One common exception in C and C++ is inline functions, which are often included in header files because most implementations cannot properly expand inline functions without seeing their definitions at compile time.)

Alternatives

Header files are not the only solution to the problem of accessing identifiers declared in different files. They have the disadvantage that it may still be necessary to make changes in two places (a source file and a header file) whenever a definition changes. Some newer languages (such as Java) dispense with header files and instead use a naming scheme that allows the compiler to locate the source files associated with interfaces and class implementations.

Class definitions (how the class looks, members, functions, etc) and function prototypes (how the function looks, what arguments it takes, etc) is placed inside headers.
All other source code is placed inside .cpp files (the only exception to this rule is templates - they, too, go into headers).

You declare things that are used in multiple places [or likely to be so in the future] in header files. If it's not needing to be shared between different places, then it doesn't need to be (and thus shouldn't be) in a header file.

What you declare inside a class follows the same rule. You usually declare classes in header files, but a class can be declared anywhere, as long as it's declared before its use.

--
Mats

Originally Posted by Kaidao

....and what I need to put in class files. Thanks for your help.

Your code! Declarations and class definitions only shows the layout of classes and how what arguments functions takes.
The actual source is done in .cpp files.

Function prototype (declarations) (example):

Code:

void foo(int a, int b);

Class definition (example):

Code:

class myclass
{
public:
   void foo();
private:
   int myint;
};

Templates:

Code:

template<typename T> void foo(T arg)
{
    // My code
}

All these go into headers. Rest go into .cpp files.

http://faq.cprogramming.com/cgi-bin/...&id=1043284392