Structure of a C Program: Every Section Explained With Examples

Preprocessor Directives

Preprocessor directives are instructions starting with #. They are processed by the C preprocessor before the compiler sees your code — they are not C statements and do not end with semicolons. They always appear at the very top of the file.

The three you will use most often:

/* 1. File inclusion — inserts the header's full contents */
#include <stdio.h>    // system header (angle brackets)
#include "myutils.h"  // your own header (quotes)

/* 2. Macro constants — replaced everywhere in the code */
#define MAX_SIZE   1024
#define PI         3.14159265
#define SQUARE(x)  ((x) * (x))   // function-like macro

/* 3. Conditional compilation — include code only on certain platforms */
#ifdef _WIN32
    #include <windows.h>
#else
    #include <unistd.h>
#endif

Global Declarations

Global declarations appear after the preprocessor section and before any function definitions. They include: global variables, struct and union type definitions, typedef aliases, and enum definitions. Anything declared globally is visible to every function in the file.

/* Global variable — shared by all functions */
int error_count = 0;

/* Struct type definition — usable everywhere below */
typedef struct {
    double x, y;
} Point;

/* Enum — named integer constants */
typedef enum { RED, GREEN, BLUE } Color;

/* Constant — prefer this over #define for typed constants (C99+) */
const int MAX_PLAYERS = 4;

Function Prototypes

A function prototype is a function declaration without a body — it tells the compiler the function's name, return type, and parameter types. This allows main() to call functions that are fully defined later in the file.

Without prototypes, the compiler encounters a call to an unknown function and either emits an "implicit declaration" warning (risky: it assumes the return type is int) or an error in C99 and later.

/* Prototypes — note the semicolons, no body */
double circle_area(double radius);
int    clamp(int value, int min, int max);
void   print_table(int *data, int size);

/* Parameter names are optional in prototypes (types are enough) */
double circle_area(double);   // also valid

The main() Function

main() is mandatory in every C program — it is the entry point the OS calls when your program starts. There can only be one main() across all source files. It must return int.

Two valid signatures:

/* Signature 1: no command-line arguments */
int main() {
    // program logic
    return 0;
}

/* Signature 2: with command-line arguments */
int main(int argc, char *argv[]) {
    // argc = number of arguments (including program name)
    // argv = array of argument strings
    // argv[0] = program name, argv[1] = first argument, etc.
    return 0;
}

main() should be kept short and high-level. Its job is to orchestrate the program — call functions, handle the top-level flow — not to contain every line of logic. Complex operations belong in helper functions.

Helper Functions

Helper functions contain the actual implementation of your program's logic. They appear after main() in a single-file program, or in separate .c files in larger projects. Each helper function should do exactly one thing — this is the "single responsibility principle" that makes C code maintainable.

#include <stdio.h>
#include <string.h>

/* --- Prototypes --- */
void greet(const char *name);
int  count_vowels(const char *str);

/* --- main() --- */
int main() {
    greet("Alice");
    printf("Vowels in 'programming': %d\n",
           count_vowels("programming"));
    return 0;
}

/* --- Helper functions --- */
void greet(const char *name) {
    printf("Hello, %s!\n", name);
}

int count_vowels(const char *str) {
    int count = 0;
    for (int i = 0; str[i]; i++) {
        char c = str[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}