C Notes
HubApplications of C Programming LanguageFeatures of C Programming LanguageHistory of C Programming LanguageWhat is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with ExplanationGCC Compiler - Complete Guide to GNU C CompilerInstall C Compiler on Linux - GCC Setup Guide for All DistrosInstall C Compiler on macOS - Xcode Command Line Tools and Homebrew GCCInstall C Compiler on Windows - MinGW, MSYS2, and WSL GuideSetup VS Code for C Programming - Complete Configuration GuideC Syntax Rules — Complete GuideComments in C ProgrammingConstants in C ProgrammingData Types in CIdentifiers in C ProgrammingKeywords in C ProgrammingStructure of a C ProgramVariables in C ProgrammingArithmetic Operators in C ProgrammingAssignment Operators in C ProgrammingBitwise Operators in C ProgrammingIncrement and Decrement Operators in CLogical Operators in C ProgrammingRelational Operators in C ProgrammingTernary Operator in C ProgrammingBreak Statement in C ProgrammingContinue Statement in C ProgrammingDo-While Loop in C ProgrammingFor Loop in C ProgrammingGoto Statement in C Programmingif-else Statement in C Programmingif Statement in C ProgrammingNested if Statements in C ProgrammingSwitch Statement in C ProgrammingWhile Loop in C ProgrammingFunction Arguments in C - Pass by Value vs Pass by ReferenceFunction Call in C ProgrammingFunction Declaration (Prototype) in CFunction Definition in C ProgrammingIntroduction to Functions in C ProgrammingRecursion in C ProgrammingReturn Statement in C ProgrammingStorage Classes in C ProgrammingArray Operations in C - Searching, Sorting, Insert and DeleteArray Programs in C - Reverse, Rotate, Duplicates, MergeIntroduction to Arrays in C ProgrammingMultidimensional Arrays in C ProgrammingOne Dimensional Arrays in C ProgrammingPassing Arrays to Functions in CTwo Dimensional Arrays in C ProgrammingString Comparison in C - strcmp, strncmp, Case-InsensitiveString Functions in C - strlen, strcpy, strcat, strcmpC String Handling Library - Complete string.h ReferenceString Manipulation in C - Reverse, Uppercase, PalindromeString Programs in C - Anagram, Word Count, Vowels, FrequencyStrings in C Programming - Complete IntroductionDouble Pointers in C - Pointer to PointerPointer Arithmetic in C ProgrammingPointer Declaration and Initialization in CPointer Programs in C - Swap, String Reversal, Dynamic AllocationPointers and Arrays in C - The Relationship ExplainedPointers and Functions in C - Pass by ReferenceIntroduction to Pointers in C ProgrammingVoid Pointers in C - Generic Pointers Guidecalloc() in C – Contiguous Memory AllocationDynamic Arrays in C – Runtime-Sized Arraysfree() in C – Releasing Dynamic Memorymalloc() in C – Dynamic Memory AllocationMemory Management Best Practices in Crealloc() in C – Resizing Dynamic MemoryBinary Files in C – fread and fwriteFile Handling in C – IntroductionFile Handling Projects in C – Student Records & Phone BookFile Modes in C – Complete Guidefopen() and fclose() in C – Opening and Closing FilesReading Files in C – fgetc, fgets, fscanf, freadWriting Files in C – fputc, fputs, fprintf, fwriteConditional Compilation in C – #ifdef, #ifndef, #if#define Macros in C – Constants and Macro FunctionsHeader Files in C – Creating Custom Headers#include Directive in C – File InclusionMacro Functions in C – Parameterized MacrosC Preprocessor – Overview and DirectivesGraphs in C – Adjacency Matrix, Adjacency List, BFS, and DFSHash Tables in C – Implementation, Collision Handling, and ChainingLinked List in C – Singly, Doubly, and Circular with ImplementationQueue in C – Linear, Circular, and Priority Queue ImplementationStack in C – Array and Linked List Implementation with ApplicationsTrees in C – Binary Search Tree Implementation with TraversalsC Programming Best Practices – Coding Standards, Safety, and PerformanceBit Fields in C – Definition, Use Cases, and Protocol HeadersC Standard Library Overview – All Headers and Common FunctionsCommand Line Arguments in C – argc and argv ExplainedDebugging Techniques in C – GDB, Valgrind, and SanitizersFunction Pointers in C – Complete Guide with ExamplesMemory Layout of a C Program – Text, Data, BSS, Heap, StackBank Management System in C – Complete Project with File StorageFile Encryption Tool in C – XOR Cipher ImplementationLibrary Management System in C – Complete Project with Source CodeMini Compiler in C – Lexer and Parser for Simple ExpressionsSnake Game in C – Console-Based Game with Source CodeStudent Management System in C – Complete Project with Source CodeC Programming Cheatsheet – Complete Quick Reference GuideTop 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with AnswersOutput Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with AnswersCommon C Programming Errors and Solutions – Debugging GuideImportant C Programs – 50+ Frequently Asked Programs with SolutionsQuick Revision Notes for C Programming – Complete C in 10 MinutesRecommended C Programming Books – From Beginner to ExpertFormat Specifiers in C - Complete Referencegetchar() and putchar() in C Programminggets() and puts() in C ProgrammingC Input Output Programs and Examplesprintf() Function in C Programmingscanf() Function in C ProgrammingArrays of Structures in C – Managing CollectionsEnums in C – Enumerated Data TypesNested Structures in C – Struct Within StructPointers to Structures in C – Arrow OperatorStructures in C – User-Defined Data Typestypedef in C – Creating Type AliasesUnions in C – Shared Memory Data Types
Complete guide to creating custom header files in C — what goes in a header, include guards, separating declaration from definition, multi-file projects, best practices, practical examples.
As your C programs grow beyond a single file, you need a way to share declarations (function prototypes, type definitions, constants) between files. That's what header files are for. They're the interface — the "public API" — of your code modules.
What is a Header File?
A header file (.h) contains declarations that are shared between multiple source files (.c). It tells other files "what exists" without revealing "how it works."
| math_utils.h | math_utils.c | |
|---|---|---|
| (WHAT - interface) | (HOW - implementation) | |
| double add(double, | double add(double a, | |
| double); | double b) | |
| double sqrt(double); | { return a + b; } | |
| #define PI 3.14159 | ... |
What Goes in a Header File
DO put in headers:
c example
// Function prototypes (declarations)
int calculate_sum(int arr[], int n);
char *str_reverse(const char *str);
// Type definitions
typedef struct {
double x, y;
} Point;
// Struct declarations
struct LinkedList;
// Macros and constants
#define MAX_BUFFER_SIZE 1024
#define VERSION "2.0.1"
// Enum definitions
enum Color { RED, GREEN, BLUE };
// External variable declarations
extern int global_count;
// Inline functions (small, frequently called)
static inline int max(int a, int b) { return a > b ? a : b; }DON'T put in headers:
Example
// Function definitions (implementation) — put in .c file
int calculate_sum(int arr[], int n) {
int sum = 0;
for (int i = 0; i < n; i++) sum += arr[i];
return sum; // This causes multiple definition errors!
}
// Variable definitions (without extern)
int global_count = 0; // Multiple definitions if included in 2+ files!
Creating Your First Header
Step 1: The Header File
c example
// calculator.h
#ifndef CALCULATOR_H
#define CALCULATOR_H
// Function declarations
double calc_add(double a, double b);
double calc_subtract(double a, double b);
double calc_multiply(double a, double b);
double calc_divide(double a, double b);
double calc_power(double base, int exponent);
// Constants
#define CALC_VERSION "1.0"
#define CALC_PI 3.14159265358979
#endif // CALCULATOR_HStep 2: The Implementation File
Example
// calculator.c
#include "calculator.h"
#include <stdio.h>
double calc_add(double a, double b) {
return a + b;
}
double calc_subtract(double a, double b) {
return a - b;
}
double calc_multiply(double a, double b) {
return a * b;
}
double calc_divide(double a, double b) {
if (b == 0.0) {
fprintf(stderr, "Error: Division by zero!\n");
return 0.0;
}
return a / b;
}
double calc_power(double base, int exponent) {
double result = 1.0;
for (int i = 0; i < exponent; i++) {
result *= base;
}
return result;
}
Step 3: Using the Header
c example
// main.c
#include <stdio.h>
#include "calculator.h"
int main() {
printf("Calculator v%s\n\n", CALC_VERSION);
double a = 10.0, b = 3.0;
printf("%.1f + %.1f = %.1f\n", a, b, calc_add(a, b));
printf("%.1f - %.1f = %.1f\n", a, b, calc_subtract(a, b));
printf("%.1f * %.1f = %.1f\n", a, b, calc_multiply(a, b));
printf("%.1f / %.1f = %.4f\n", a, b, calc_divide(a, b));
printf("%.1f ^ %d = %.1f\n", 2.0, 10, calc_power(2.0, 10));
return 0;
}Compile: gcc main.c calculator.c -o calculator
Output
Calculator v1.0 10.0 + 3.0 = 13.0 10.0 - 3.0 = 7.0 10.0 * 3.0 = 30.0 10.0 / 3.0 = 3.3333 2.0 ^ 10 = 1024.0
Include Guards in Detail
c example
// Without guards — PROBLEM:
// main.c includes "a.h" and "b.h"
// b.h also includes "a.h"
// → a.h content appears TWICE → redefinition errors!
// With guards — SOLUTION:
#ifndef MY_HEADER_H // First time: not defined → proceed
#define MY_HEADER_H // Now it's defined
struct Point { int x, y; }; // Included once
#endif // End of guard
// Second inclusion: MY_HEADER_H already defined → entire block skippedGuard Naming Conventions
c example
// Use unique, project-scoped names:
#ifndef PROJECTNAME_MODULE_FILENAME_H
#define PROJECTNAME_MODULE_FILENAME_H
// Examples:
#ifndef MYAPP_NETWORK_HTTP_H
#ifndef GAME_ENGINE_PHYSICS_H
#ifndef STUDENT_DB_RECORDS_HMulti-File Project Structure
project/
├── include/ ← Header files
│ ├── student.h
│ ├── database.h
│ └── utils.h
├── src/ ← Source files
│ ├── student.c
│ ├── database.c
│ ├── utils.c
│ └── main.c
├── Makefile
└── README.md
Compile with include path: gcc -Iinclude src/*.c -o program
Complete Multi-Module Example
Example
// student.h
#ifndef STUDENT_H
#define STUDENT_H
#define MAX_NAME 50
#define MAX_STUDENTS 100
typedef struct {
int id;
char name[MAX_NAME];
float gpa;
} Student;
// Public interface
Student student_create(int id, const char *name, float gpa);
void student_print(const Student *s);
int student_compare_by_gpa(const Student *a, const Student *b);
#endif
Example
// student.c
#include <stdio.h>
#include <string.h>
#include "student.h"
Student student_create(int id, const char *name, float gpa) {
Student s;
s.id = id;
strncpy(s.name, name, MAX_NAME - 1);
s.name[MAX_NAME - 1] = '\0';
s.gpa = gpa;
return s;
}
void student_print(const Student *s) {
printf(" [%d] %-20s GPA: %.2f\n", s->id, s->name, s->gpa);
}
int student_compare_by_gpa(const Student *a, const Student *b) {
if (a->gpa > b->gpa) return -1;
if (a->gpa < b->gpa) return 1;
return 0;
}
Example
// main.c
#include <stdio.h>
#include <stdlib.h>
#include "student.h"
int compare_wrapper(const void *a, const void *b) {
return student_compare_by_gpa((const Student *)a, (const Student *)b);
}
int main() {
Student class_list[] = {
student_create(1, "Alice", 3.85),
student_create(2, "Bob", 3.92),
student_create(3, "Charlie", 3.67),
student_create(4, "Diana", 3.95)
};
int n = 4;
printf("Students (sorted by GPA):\n");
qsort(class_list, n, sizeof(Student), compare_wrapper);
for (int i = 0; i < n; i++) {
student_print(&class_list[i]);
}
return 0;
}
Output
Students (sorted by GPA): [4] Diana GPA: 3.95 [2] Bob GPA: 3.92 [1] Alice GPA: 3.85 [3] Charlie GPA: 3.67
Header File Best Practices
| Practice | Why |
|---|---|
| Always use include guards | Prevents redefinition errors |
| Include only what you need | Reduces compilation time |
| Put the header's own #include at top of .c | Catches missing dependencies |
| Keep headers minimal | Less to recompile when changed |
| Use forward declarations | Reduce include chains |
Never put static functions in headers | Each .c gets a separate copy |
| Document the public API | Headers are your module's interface |
Opaque Pointers — Information Hiding
c example
// database.h — public interface
#ifndef DATABASE_H
#define DATABASE_H
// Opaque type — users can't see inside
typedef struct Database Database;
Database *db_open(const char *filename);
void db_close(Database *db);
int db_insert(Database *db, const char *key, const char *value);
const char *db_get(Database *db, const char *key);
#endifExample
// database.c — private implementation
#include "database.h"
#include <stdlib.h>
// Full definition is ONLY in the .c file
struct Database {
char filename[256];
int record_count;
// ... internal fields hidden from users
};
Database *db_open(const char *filename) {
Database *db = malloc(sizeof(Database));
// ... implementation
return db;
}
Users of database.h can only use Database * pointers — they can't access internal fields.
Interview Questions
Q1: What is the difference between a header file and a source file?
A header (.h) contains declarations (what exists — prototypes, types, macros). A source file (.c) contains definitions (how it works — function bodies, variable values). Headers are shared via #include; source files are compiled separately and linked together.
Q2: Why should you never define functions in header files?
If a header defines a function and is included by two .c files, both will contain the function's compiled code. The linker will report "multiple definition" errors. Only declare functions in headers; define them in exactly one .c file.
Q3: What is an opaque pointer and why is it useful?
An opaque pointer is a pointer to a struct whose definition is hidden from the user (only declared in the header, defined in the .c file). Users can pass the pointer around but can't access internal fields. This provides encapsulation — you can change the struct's internals without affecting users.
Q4: What happens if you forget include guards?
If a header is included more than once (directly or indirectly), its contents are duplicated. This causes "redefinition" compilation errors for types, structs, and enums. Without guards, complex projects with many includes become impossible to compile.
Summary
- Header files declare the public interface of a module
- Source files provide the implementation
- Always use include guards (
#ifndef/#define/#endif) - Put only declarations, macros, and type definitions in headers
- Never define functions or non-extern variables in headers
- Use opaque pointers for information hiding (encapsulation)
- Organize projects with separate include/ and src/ directories
- Compile with
gcc -I<include_path> src/*.c -o program
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Header Files in C – Creating Custom Headers.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.
Search Terms
c-programming, c programming, programming, preprocessor, header, files, header files in c – creating custom headers
Related C Programming Topics
Continue learning this concept
PreprocessorConditional Compilation in C – #ifdef, #ifndef, #ifComplete guide to conditional compilation in C — #ifdef, #ifndef, #if, #elif, #else, #endif directives, platform-specific code, debug builds, feature toggles, practical examples.Preprocessor#define Macros in C – Constants and Macro FunctionsComplete guide to #define macros in C — defining constants, function-like macros, macro pitfalls, multiline macros, stringification, token pasting, common patterns and best practices.Preprocessor#include Directive in C – File InclusionComplete guide to #include in C — angle brackets vs quotes, header file search paths, header guards, preventing multiple inclusion, system vs user headers, practical examples.PreprocessorMacro Functions in C – Parameterized MacrosComplete guide to macro functions in C — parameterized macros, variadic macros, do-while trick, inline comparison with macros, safe macro patterns, debugging macros, practical examples.PreprocessorC Preprocessor – Overview and DirectivesComplete guide to the C preprocessor — what it is, how it works, preprocessing stages, all preprocessor directives overview, #pragma, #error, #line, predefined macros, practical examples.File HandlingBinary Files in C – fread and fwriteComplete guide to binary file handling in C — reading and writing binary data with fread/fwrite, struct serialization, random access with fseek, database-like operations, practical examples.