A .h file is a header file that holds declarations — the names and shapes of functions and data that other code files will use
When programmers write code in languages like C or C++, they split their work across multiple files. A .h file (the "h" stands for header) is a text file that tells other code files what tools are available to them without showing how those tools actually work. Think of it like a restaurant menu: the menu lists what you can order, but it does not explain how the kitchen makes each dish.
The .h file contains declarations — statements that say "this function exists" or "this data structure exists" — but not the actual working code, called the definition. That definition lives in a separate file, usually a .c or .cpp file. When you write code in one file and want to use a function from another file, you tell your compiler "look at this .h file to see what's available," and the compiler trusts that the definition will show up later.
Without .h files, every code file would have to repeat all the declarations it needed, and if you changed something, you would have to change it in dozens of places. The .h file solves this by being the single source of truth about what each piece of code offers.
Key Takeaways
- A .h file contains declarations that tell other code files what functions and data structures are available, without showing the actual working code.
- The actual working code lives in a separate .c or .cpp file, which is where the function definition is written.
- You include a .h file in your code using a statement like #include "filename.h", which copies those declarations into your current file.
- Using .h files prevents you from having to repeat the same declarations in multiple places and makes it easier to change code without breaking other files.
- .h files are most common in C and C++, though other languages use similar patterns with different file names.
How a .h file and a .c file work together
A typical project has pairs of files: one .h file and one .c file (or .cpp file for C++). The .h file is the public face; the .c file is the engine. When you write code in a third file and need to use a function from the pair, you include the .h file, not the .c file.
Here is a concrete example. Suppose you write a function called add_numbers that takes two numbers and returns their sum. In the .h file, you write a declaration: int add_numbers(int a, int b); This line says "a function called add_numbers exists, it takes two integers, and it returns an integer." In the .c file, you write the actual code that does the addition. When another file needs to use add_numbers, it includes the .h file, sees the declaration, and can call the function. The compiler later links everything together and finds the actual definition in the .c file.
This separation means you can change how add_numbers works inside the .c file without touching any other file. As long as the declaration in the .h file stays the same, all the code that uses it keeps working.
What goes inside a .h file
A .h file typically contains function declarations, data structure definitions (like structs), and constant definitions. It does not contain the actual code that runs — that belongs in the .c or .cpp file. The .h file is purely informational: it tells the compiler and other programmers what is available.
Most .h files also include guard statements at the top and bottom. These are lines like #ifndef FILENAME_H and #define FILENAME_H that prevent the file from being included twice by accident. If a .h file gets included twice, the compiler would see duplicate declarations and throw an error. The guard stops that from happening.
Comments are also common in .h files. Programmers use them to explain what each function does, what arguments it expects, and what it returns. Since the .h file is often the first place another programmer looks when they want to use your code, clear comments save time and prevent mistakes.
How to include a .h file in your code
To use a .h file, you write an include statement at the top of your code file. There are two forms: #include "filename.h" and #include <filename.h> The difference matters. Quotes tell the compiler to look for the file in your project folder first. Angle brackets tell it to look in the system folders where standard libraries live.
When you write #include "math_functions.h", the compiler reads that file, copies all the declarations into your current file, and then compiles your code. Your code can now call any function declared in math_functions.h. If the declaration is not there, the compiler will complain that the function is unknown.
You can include multiple .h files in a single code file. A large project might include five or ten different headers, each offering a different set of tools. The order usually does not matter, but if one .h file depends on declarations from another, you have to include them in the right order.
Why programmers use .h files instead of putting everything in one file
Splitting code into .h and .c files serves several practical purposes. First, it keeps files small and readable. A single massive file with thousands of lines is hard to navigate and debug. Smaller, focused files are easier to understand and change.
Second, it prevents circular dependencies. If file A needs something from file B, and file B needs something from file A, the compiler can get confused. By separating declarations from definitions, you can often break these loops. File A includes the .h file from B (which is just declarations), and file B includes the .h file from A, and the compiler can sort it out.
Third, it makes teamwork easier. One programmer can write the .h file and the interface, and another can write the .c file with the actual code. They can work in parallel as long as they agree on what the .h file says. Changes to the .c file do not affect anyone else's work as long as the .h file stays the same.
The difference between .h files and .c files
| Aspect | .h File (Header) | .c File (Implementation) |
|---|---|---|
| What it contains | Declarations, struct definitions, constants | Actual working code, function definitions |
| What other files see | Included in other files via #include | Compiled separately, linked later |
| Can it run on its own? | No, it is just information | No, it needs a main() function to run |
| What happens if you change it? | All files that include it must be recompiled | Only this file needs to be recompiled |
Common mistakes when working with .h files
One frequent mistake is forgetting to include the .h file. You write code that calls a function, but you never included the header, so the compiler does not know the function exists. The error message will say something like "undefined reference" or "unknown function." The fix is to add the include statement at the top of your file.
Another mistake is putting actual code (function definitions) in the .h file instead of just declarations. If you do this and include the .h file in multiple places, the compiler will see the same function defined twice and throw an error. The rule is simple: declarations go in .h files, definitions go in .c files.
A third mistake is forgetting the include guard. If a .h file does not have guard statements and gets included twice, you will see duplicate declaration errors. Modern compilers have a shortcut called #pragma once that does the same job with one line, but the traditional guard statements work everywhere.
Frequently Asked Questions
Do I have to use .h files, or can I put everything in one .c file?
You can put everything in one file for very small programs, and it will work. But as your code grows, a single file becomes hard to manage. Using .h files is a habit that pays off as projects get larger. Most real-world C and C++ projects use them.
What is the difference between #include with quotes and angle brackets?
Quotes like #include "myfile.h" tell the compiler to look in your project folder first. Angle brackets like #include <stdio.h> tell it to look in the system library folders. Use quotes for your own .h files and angle brackets for standard libraries.
Can a .h file include another .h file?
Yes, and it is common. If your math_functions.h needs a data structure defined in data_types.h, you can include data_types.h inside math_functions.h. This is why include guards are important — they prevent the same file from being included multiple times by accident.
What happens if I change a .h file?
Every .c file that includes it must be recompiled. The compiler needs to read the new declarations and make sure all the code that uses them is still correct. This is why keeping .h files stable is important in large projects — changing them can trigger a lot of recompilation.
Are .h files used in languages other than C and C++?
Not with the same name. Languages like Java and Python handle this differently — Java uses packages and import statements, Python uses modules. But the idea is the same: separating what is available (the interface) from how it works (the implementation).