Basic Example

suggest change

The following example will contain a block of code that is meant to be split into several source files, as denoted by // filename comments.

Source Files

// my_function.h

/* Note how this header contains only a declaration of a function.
 * Header functions usually do not define implementations for declarations
 * unless code must be further processed at compile time, as in templates.

/* Also, usually header files include preprocessor guards so that every header
 * is never included twice.
 * The guard is implemented by checking if a header-file unique preprocessor
 * token is defined, and only including the header if it hasn't been included
 * once before.

// global_value and my_function() will be
// recognized as the same constructs if this header is included by different files.
const int global_value = 42;
int my_function();

#endif // MY_FUNCTION_H

—``` // my_function.cpp

/* Note how the corresponding source file for the header includes the interface * defined in the header so that the compiler is aware of what the source file is * implementing. In this case, the source file requires knowledge of the global constant * global_value only defined in my_function.h. Without inclusion of the header * file, this source file would not compile. */ #include “my_function.h” // or #include “my_function.hpp” int my_function() { return global_value; // return 42; }


Header files are then included by other source files that want to use the functionality defined by the header interface, but don’t require knowledge of its implementation (thus, reducing code coupling). The following program makes use of the header `my_function.h` as defined above:

// main.cpp

#include // A C++ Standard Library header. #include “my_function.h” // A personal header

int main(int argc, char** argv) { std::cout << my_function() << std::endl; return 0; }


# The Compilation Process

Since header files are often part of a compilation process workflow, a typical compilation process making use of the header/source file convention will usually do the following.

Assuming that the header file and source code file is already in the same directory, a programmer would execute the following commands:

g++ -c my_function.cpp # Compiles the source file my_function.cpp # –> object file my_function.o

g++ main.cpp my_function.o # Links the object file containing the # implementation of int my_function() # to the compiled, object version of main.cpp # and then produces the final executable a.out

Alternatively, if one wishes to compile `main.cpp` to an object file first, and
then link only object files together as the final step:

g++ -c my_function.cpp g++ -c main.cpp

g++ main.o my_function.o ```

Feedback about page:

Optional: your email if you want me to get back to you:

Table Of Contents