C Syntax: The Structure of a C Program Explained

C has very little syntax to learn - about 32 keywords and a handful of punctuation rules. Almost every program you will ever write has the same outer shape, so it is worth taking that shape apart once and carefully.

The Smallest Complete Program

This compiles, runs, and does nothing:

int main(void) {
    return 0;
}

No includes, no output, no boilerplate class or module. main is the entry point: when the operating system starts your program, it calls main. When main returns, the program ends, and the value it returns is the exit status.

Add output and you need one include:

#include <stdio.h>

int main(void) {
    printf("Hello, C!\n");
    return 0;
}

Preprocessor Directives

Lines beginning with # are handled before compilation proper, by the preprocessor. They are not C statements, and they take no semicolon.

#include <stdio.h>    /* standard library header - angle brackets */
#include "myutils.h"  /* your own header - quotes, searched locally first */
#define MAX 100       /* a macro - MAX is replaced by 100 everywhere below */

#include is a literal text paste: the entire contents of the named file are dropped in at that point. stdio.h contains the declaration of printf, which is how the compiler knows what arguments printf takes. Leave the include out and you get implicit declaration of function 'printf'.

The angle-bracket versus quote distinction is about where the compiler searches: <...> means the system include directories, "..." means look next to this file first.

The main Function

int main(void) {
    return 0;
}

Four parts, each meaningful:

• int - main's return type. The value goes to the operating system as the exit status, where 0 means success.
• main - the reserved name the runtime calls. Every hosted C program has exactly one.
• (void) - the parameter list. void here means "takes no arguments." Writing main() instead is legal but weaker: empty parentheses in C mean "unspecified parameters," which disables argument checking.
• { ... } - the function body.

The other standard form takes command-line arguments:

int main(int argc, char *argv[]) { ... }

Use int main(void) until you need them.

Statements and Semicolons

A statement is a single instruction, and it ends with a semicolon.

#include <stdio.h>

int main(void) {
    int a = 5;
    int b = 7;
    int sum = a + b;
    printf("%d + %d = %d\n", a, b, sum);
    return 0;
}

Four statements, four semicolons. The semicolon is a terminator, not a separator - the last statement in a block needs one too.

What does not take a semicolon:

#include <stdio.h>        /* preprocessor line - no semicolon */

int add(int a, int b) {   /* function definition header - no semicolon */
    return a + b;
}                         /* closing brace of a function - no semicolon */

if (x > 0) {
    ...
}                         /* closing brace of a control block - no semicolon */

The one case that bites everyone is a semicolon where a body should be:

if (score > 90);              /* BUG: this ; is the entire if body */
    printf("Excellent!\n");   /* always runs, whatever score is */

That is perfectly legal C. The if controls an empty statement, and the printf is just the next line in sequence. -Wall warns about it; the compiler will not stop you.

Blocks and Braces

Curly braces group statements into a block, which counts as one statement wherever a statement is expected.

#include <stdio.h>

int main(void) {
    int temp = 35;

    if (temp > 30) {
        printf("It is hot.\n");
        printf("Drink water.\n");
    }

    return 0;
}

Braces are optional when the body is a single statement, but omitting them is how the famous bugs happen - add a second line later and it silently leaves the if. Use braces always.

Blocks also create scope: a variable declared inside { ... } stops existing at the closing brace.

#include <stdio.h>

int main(void) {
    int outer = 1;

    {
        int inner = 2;
        printf("inside: outer=%d inner=%d\n", outer, inner);
    }

    /* inner does not exist here */
    printf("outside: outer=%d\n", outer);
    return 0;
}

Case Sensitivity and Whitespace

C is case sensitive everywhere. total, Total, and TOTAL are three separate names. Every keyword is lowercase, so Int, Return, and Printf are all errors - and the error message for Printf is confusing, because the compiler assumes you meant some function it has never heard of.

Whitespace, by contrast, is almost entirely free. The compiler treats any run of spaces, tabs, and newlines as one separator. This is valid:

int    main ( void )
{
    printf
    ( "Hello\n" ) ;
    return 0 ;
}

So is this:

int main(void){printf("Hello\n");return 0;}

Both compile identically. Since the compiler does not care, formatting is entirely for humans - and the conventional layout (one statement per line, four spaces or one tab per nesting level, opening brace on the same line) is worth following because every C codebase you read will use something close to it.

Two places whitespace does matter: you cannot split a keyword or identifier (in t is not int), and you cannot put a newline inside a normal string literal.

Identifiers: Naming Rules

An identifier is any name you choose - variables, functions, types. The rules:

• Made of letters, digits, and underscores.
• Must not start with a digit. total2 is fine, 2total is not.
• Cannot be a keyword: no variable called int, for, or return.
• Case matters.
• Names starting with an underscore, and anything with two underscores in a row, are reserved for the implementation - do not invent them.

int score;        /* good */
int total_items;  /* good - snake_case is the C convention */
int _hidden;      /* legal but reserved - avoid */
int 2fast;        /* error */
int float;        /* error - keyword */

A Fully Annotated Program

Everything above, in one place:

#include <stdio.h>          /* brings in printf */

#define TAX_RATE 0.08       /* a compile-time constant */

/* A function definition: return type, name, parameters, body. */
double with_tax(double price) {
    return price + price * TAX_RATE;
}

int main(void) {            /* execution starts here */
    double item = 25.0;     /* declaration + initialization */
    double total;           /* declaration only */

    total = with_tax(item); /* call the function, assign the result */

    /* %.2f prints a double with two decimal places */
    printf("Item:  %.2f\n", item);
    printf("Total: %.2f\n", total);

    if (total > 25.0) {     /* a block controlled by a condition */
        printf("Tax was applied.\n");
    }

    return 0;               /* exit status: success */
}

Reading order matters here: with_tax is defined before main uses it. C reads the file from top to bottom, so a function must be declared before it is called. Define it earlier, or write a function prototype at the top and define it later.