Why C++ Uses Header Files and .cpp Files

C++ separates a program’s public declarations from its implementation details. Header files let multiple source files know that a class, function, or variable exists, while .cpp files contain the code that defines how it works. This structure supports separate compilation, code reuse, faster rebuilds, and clearer interfaces.

C++ projects are usually split into multiple source files. Each .cpp file is compiled independently into an object file, and a linker later combines those object files into one executable or library.

A .cpp file cannot automatically see names declared in another .cpp file. It needs a declaration first. Header files provide a shared place for those declarations.

For example, a header can declare a function:

// greeting.h
#ifndef GREETING_H
#define GREETING_H

#include <string>

std::string makeGreeting(const std::string& name);

#endif

A source file can define it:

// greeting.cpp
#include "greeting.h"

std::string makeGreeting(const std::string& name) {
    return "Hello, " + name + "!";
}

Other source files can include the header and call the function without needing to know its implementation:

// main.cpp
#include "greeting.h"
#include <iostream>

int main() {
    std::cout << makeGreeting("Ada") << '\n';
}

This distinction is important:

• A declaration tells the compiler a name, its type, and how it may be used.
• A definition creates the function body, class storage, or variable storage.
• A header normally contains declarations meant to be shared.
• A .cpp file normally contains definitions and private implementation code.

The convention is not enforced by the C++ language: a header is text included into another file, and .cpp is a common source-file extension. However, this organization matches C++'s compilation model and is widely used in real codebases.

Separating interface from implementation means users of a component can rely on what it does without depending on how it is written internally. If an implementation changes but its declaration stays the same, other source files may not need changes or recompilation.

Think of a header as a restaurant menu and a .cpp file as the kitchen.

• The menu lists what customers can order: function names, parameter types, return types, and classes.
• The kitchen contains the recipes and actual work: function bodies and internal helper code.
• A customer does not need to know the recipe to order a meal.

Similarly, code that includes a header can call a function without seeing its implementation. During the build, the linker connects the call in one compiled file to the function implementation compiled from another .cpp file.

A typical small C++ component has a header, an implementation file, and a file that uses the component.

// calculator.h
#ifndef CALCULATOR_H
#define CALCULATOR_H

int add(int left, int right);
int subtract(int left, int right);

#endif

// calculator.cpp
#include "calculator.h"

int add(int left, int right) {
    return left + right;
}

int subtract(int left, int right) {
    return left - right;
}

// main.cpp
#include "calculator.h"
#include <iostream>

int main() {
    std::cout << add(7, 3) << '\n';
    std::cout << subtract(7, 3) << '\n';
}

The header gives main.cpp enough information to compile these calls:

add(7, 3);

It knows that add accepts two int values and returns an int. The compiler does not need the body of add at that moment. Later, the linker finds the compiled definition from calculator.cpp.

Class example

A class declaration is commonly placed in a header, while non-trivial member function definitions go in a .cpp file.

// counter.h
#ifndef COUNTER_H
#define COUNTER_H

class Counter {
public:
    void increment();
    int value() const;

private:
    int count_ = 0;
};

#endif

// counter.cpp
#include "counter.h"

void Counter::increment() {
    ++count_;
}

int Counter::value() const {
    return count_;
}

Any file that wants to create a Counter includes counter.h; it does not need to include counter.cpp.

Consider these three files.

// message.h
#ifndef MESSAGE_H
#define MESSAGE_H

void printMessage();

#endif

// message.cpp
#include "message.h"
#include <iostream>

void printMessage() {
    std::cout << "Build complete\n";
}

// main.cpp
#include "message.h"

int main() {
    printMessage();
}

A simplified build proceeds as follows:

1. The compiler starts compiling main.cpp.
2. #include "message.h" effectively inserts the contents of message.h into main.cpp before compilation.
3. The compiler sees void printMessage();, so it accepts the call to printMessage() in main.
4. The compiler produces an object file, such as main.o. At this stage, it knows a printMessage definition must be found later.
5. The compiler separately compiles message.cpp. Its include gives the definition a declaration to match.
6. The compiler produces message.o, which contains the compiled body of printMessage.
7. The linker combines main.o and message.o and connects the call in main to the definition in message.o.
8. When the executable runs, main calls printMessage, which writes Build complete.

For example, with a compiler that supports this command format:

g++ main.cpp message.cpp -o app

Both .cpp files must be supplied to the build. Including message.h only provides a declaration; it does not compile or link message.cpp by itself.

Header and implementation separation appears throughout C++ applications.

• Application modules: A UserService header exposes operations such as createUser and findUser; its .cpp file contains database and validation details.
• Reusable libraries: A library publishes headers so application code can use its types and functions. The library may provide already-compiled binaries containing the implementations.
• Platform-specific code: A header can expose getHomeDirectory(), while different .cpp files implement it for Windows, Linux, or macOS.
• Game projects: A Player class header declares movement and health operations; Player.cpp implements game rules and interactions.
• Embedded software: A hardware driver header exposes initialize() and readTemperature(), while the .cpp file contains device-specific communication code.
• Large teams: One developer can improve a function’s internal algorithm in a .cpp file while another uses the stable interface from its header.

Real projects use headers as deliberate interfaces, not merely as places to put declarations.

Include the corresponding header first

A common convention is to include a .cpp file’s own header first:

#include "calculator.h"

#include <stdexcept>

This helps detect missing dependencies in calculator.h. If the header relies on a type but forgets to include the necessary standard or project header, compiling calculator.cpp is more likely to expose the problem.

Keep implementation details private

Helpers used only inside one implementation file usually belong in that .cpp file:

// order.cpp
#include "order.h"

namespace {
    bool isValidQuantity(int quantity) {
        return quantity > 0;
    }
}

The helper is not declared in order.h, so other files cannot depend on it.

Validate at module boundaries

Public functions often use guard clauses in implementation files:

void Account::deposit(double amount) {
    if (amount <= 0.0) {
        throw std::invalid_argument("Deposit amount must be positive");
    }

    balance_ += amount;
}

The header promises that deposit exists; the .cpp file handles its behavior and error checking.

Minimize unnecessary includes

Headers are included by every source file that needs them. Including many large headers can slow builds. Developers therefore include only what a header needs and, where possible, use forward declarations.

class Logger;  // Declaration only; no logger.h inclusion needed here.

class ReportService {
public:
    explicit ReportService(Logger& logger);

private:
    Logger& logger_;
};

The .cpp file includes the full definition when it needs to call Logger methods:

#include "report_service.h"
#include "logger.h"

A forward declaration is appropriate only when the header can work with an incomplete type, such as through a pointer or reference. A full object member requires the complete class definition.

Including a .cpp file

Do not usually include implementation files.

// Incorrect in normal project structure
#include "calculator.cpp"

If multiple source files include the same .cpp file, the linker can see multiple definitions of the same functions. Include the header instead, and compile calculator.cpp separately.

#include "calculator.h"

Defining a non-inline function in a header

This header causes trouble when included by more than one .cpp file:

// Incorrect: utility.h
int square(int value) {
    return value * value;
}

Each including source file gets its own definition, often producing a linker error about multiple definitions. Put the body in utility.cpp, or mark a small header-defined function inline when that design is intentional:

inline int square(int value) {
    return value * value;
}

Forgetting include guards or #pragma once

A header may be included indirectly more than once. Without protection, declarations such as class definitions may be repeated in the same translation unit.

Use include guards:

#ifndef USER_H
#define USER_H

class User {
};

#endif

Many projects use #pragma once instead:

#pragma once

class User {
};

#pragma once is widely supported, while traditional include guards are standard preprocessor syntax.

Declaration and definition do not match

These are different functions because the parameter types differ:

// header
int multiply(int value, int factor);

// source: incorrect definition
int multiply(double value, int factor) {
    return static_cast<int>(value) * factor;
}

Include the corresponding header in the .cpp file so the compiler can catch mismatches.

Assuming a header causes linking

This compiles only if the build also compiles and links the file containing the definition. A declaration alone does not provide executable code. Add the relevant .cpp file or library to your build system.

Putting using namespace in a header

Avoid this:

using namespace std;

Every file that includes the header inherits that namespace choice, increasing name-collision risk. Use qualified names such as std::string in headers.

Declaration vs. definition

.h versus .hpp

Both are conventions. Many projects use .h for C and C++ headers; others use .hpp to signal a C++ header. The compiler does not assign special C++ meaning to either extension.

Header-only code versus .cpp implementation

Templates generally need their definitions visible where they are used, so template implementations are commonly written in headers. Small inline functions may also be defined in headers. Ordinary non-inline function bodies are usually kept in .cpp files.

• A header shares declarations between source files.
• A .cpp file normally contains implementations.
• #include "file.h" is preprocessor text inclusion, not runtime loading.
• Compile each .cpp file separately; link their object files together.
• Include a component’s header, not its .cpp file.
• Put include guards around normal headers:

#ifndef FILE_H
#define FILE_H
// declarations
#endif

• A declaration tells the compiler a function exists:

int add(int left, int right);

• A definition provides its body:

int add(int left, int right) {
    return left + right;
}

• Put non-inline function definitions in one .cpp file to avoid multiple-definition linker errors.
• Header-defined templates and inline functions are normal because their definitions must be available to each translation unit that uses them.
• Include the matching header first in its .cpp file.
• A header should include what it directly needs; do not rely on another header including it accidentally.

Are header files required in C++?

No. C++ does not require headers. A one-file program can place declarations and definitions in a single .cpp file. Headers become useful when declarations must be shared across multiple source files.

Why not put all C++ code in one .cpp file?

You can for a small program, but large files become difficult to navigate, reuse, test, and build efficiently. Separate files create clear component boundaries.

Does #include compile another .cpp file?

No. #include inserts text before compilation. A .cpp file must still be compiled by the build command or build system.

Why do templates usually go in header files?

The compiler generally needs to see a template’s full definition when it creates code for a particular type, such as std::vector<int>. That is why templates are commonly defined in headers.

Can a function be defined in a header file?

Yes, if it is inline, a template, or otherwise designed to obey the one-definition rule. Ordinary non-inline functions should normally have one definition in a .cpp file.

What is an include guard?

It is preprocessor code that prevents a header’s contents from being processed more than once in the same translation unit.

What does a linker error such as “undefined reference” mean?

Usually, code successfully saw a declaration and compiled, but the linker could not find the matching definition. Check that the relevant .cpp file or library is part of the build.

Should I use .h or .hpp?

Use the convention already used by your project. Both are common for C++ headers.

• Compilation and linking — Explains how independently compiled .cpp files become one executable.
• Declarations and definitions — Clarifies what the compiler needs to use a name versus create it.
• The C++ preprocessor and #include — Explains how header contents are inserted before compilation.
• Include guards — Prevent repeated processing of a header in one translation unit.
• The one-definition rule — Explains why duplicate function or variable definitions can cause linker errors.
• Namespaces — Organize public names and reduce collisions between components.
• Forward declarations — Reduce header dependencies when only a pointer or reference to a type is needed.
• C++ templates — Shows why some implementation code must be visible in headers.
• Static and dynamic libraries — Package reusable C++ implementations for other programs.