Functions and Program Structure in C

A function packages one task so that another part of the program can call it. Give it a name that describes that task, and choose its inputs and result before writing its body. In an ordinary hosted C program, execution begins in main.

Build a definition

int square(int n)
{
    return n * n;
}

The definition has a return type (int), a name (square), a parameter list (int n), and a body inside braces. The parameter is the local variable that receives an input. An argument is the value supplied by a call: in square(6), that value is 6. The call produces 36. Define every function at file level, outside other functions; standard C does not allow nested function definitions.

Each parameter needs its own type. Write int max(int a, int b), with a comma separating the declarations. In a call, supply values without their types: max(8, 3).

Return a value to the caller

int max(int a, int b)
{
    if (a > b)
        return a;
    return b;
}

A return immediately ends the current call. For max(8, 3), the first return runs, so the second is never reached. A returned expression is converted to the function's return type. Choose that type to preserve the kind of result you need.

For a fractional result, use floating-point arithmetic throughout:

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

The call c_to_f(37.0) returns 98.6. An integer version using c * 9 / 5 + 32 returns 98, because the division discards the fraction. Reordering it to 9 / 5 * c + 32 makes 9 / 5 evaluate to 1 first, giving 69 for 37. A floating-point return type alone cannot undo an integer calculation already performed inside the body.

Use the result

A value-returning call is an expression. With the definition above, square(3) + square(4) gives 25. In square(square(2)), the inner call returns 4, which becomes the outer call's argument, giving 16. A statement such as square(5); is legal, but discards the returned value.

Printing and returning do different jobs. printf displays text; return supplies a result that the caller can store or use in another expression. If an ordinary non-void function reaches its closing brace without returning and the caller uses its result, behavior is undefined. Compile with -Wall -Wextra to help find missing returns.

Functions that produce no value

A void function performs a task without returning a value. It can leave early with return;. For example, void print_line(int width) can print a line of dashes, but int x = print_line(5); is invalid because the call provides no value. To take no inputs, write void in the parameter list, as in int read_sensor(void).

int main(void) returns a status to the host environment. Use return 0; for success; <stdlib.h> also supplies EXIT_SUCCESS and EXIT_FAILURE. Reaching the end of main returns zero automatically. Other value-returning functions do not get that exception.

A function call needs a declaration that the compiler has already seen. If the definition comes later, put a prototype before the first call. The prototype tells the compiler how to check the call without supplying the function's body.

Separate the promise from the body

#include <stdio.h>

double c_to_f(double c);

int main(void)
{
    printf("%.1f\n", c_to_f(25.0));
    return 0;
}

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

The prototype ends with a semicolon. The definition has a body and no semicolon between its parameter list and opening brace. A useful layout is headers, prototypes, main, then other definitions. The output here is 77.0.

Parameter names are optional in prototypes: double c_to_f(double); declares the same function. Names such as c can document an input, but they need not match the definition's names. Every declaration must agree on the return type and parameter types. A used function needs one definition; repeating compatible prototypes does not create more functions.

What the compiler checks

With a prototype, the compiler checks the argument count and converts each supplied value to the declared parameter type. Given double c_to_f(double c);, both c_to_f() and c_to_f(20.0, 5.0) have the wrong count and require a diagnostic.

A numeric type difference can instead be a permitted conversion:

int half(int n)
{
    return n / 2;
}

For half(7.9), conversion first gives the parameter the value 7. Integer division then produces 3. For half(-7.9), conversion gives -7, and division produces -3. Both discard fractional parts toward zero. The call does not preserve the original double value merely because the argument was written with a decimal point. Add -Wconversion when you want warnings about such conversions.

Say explicitly when there are no parameters

In C17, an empty parameter list in a declaration prevents full argument checking; it does not authorize arbitrary arguments to the eventual function. Use (void) consistently. GCC 15 changed its default C dialect to gnu23, so -std=c17 makes the intended standard explicit when following these examples.

Repair a declaration problem

Calling an undeclared function violates modern C. Include the standard header that declares it, such as <stdio.h> for printf, or add your own matching prototype. Current GCC and Clang normally reject implicit declarations.

A prototype such as double area(double r); cannot match a definition returning float and taking float. Include a module's header in the file that defines its functions so the compiler can compare them. Do not try to fix a type mismatch by adding a cast at the call: correct the declaration and definition to describe the same function.

C passes every argument by value: each parameter starts with a copy of its argument's value. Assigning to an ordinary integer parameter changes that copy, even if it shares a name with a caller's variable.

Trace the copy

With <stdio.h> included and this definition before its call:

void double_it(int n)
{
    n *= 2;
    printf("inside: %d\n", n);
}

The caller runs:

int score = 21;
double_it(score);
printf("after: %d\n", score);

The output is inside: 42, then after: 21. The parameter changes from 21 to 42; no statement assigns to the caller's score.

Keep a returned result

int doubled(int n)
{
    return n * 2;
}

The function computes a value; the caller's assignment updates its variable. Returning a local's value is safe: int total = a + b; return total; copies the value out before the automatic local ceases to exist. Calculations using only parameters and returned results can be tested without arranging hidden shared state.

See why a value-only swap fails

void swap(int a, int b)
{
    int t = a;
    a = b;
    b = t;
}

After int p = 3, q = 7; swap(p, q);, the caller still has p == 3 and q == 7. The body exchanged its copies. Changing caller objects through parameters requires their addresses, passed as pointer values.

Sequence arguments when order matters

Arguments may be expressions such as a + 1 or square(b). All finish before the called function's body begins, but their evaluation order is unspecified. Two calls to a state-changing next_ticket() in one print can supply tickets in either order. Use separate statements:

int first = next_ticket();
int second = next_ticket();
printf("%d %d\n", first, second);

Avoid f(i, i++): its unsequenced read and modification of i give undefined behavior.

A call pauses its caller until a result is ready. Tracing the active calls explains how a program returns to the right place and why recursion needs a stopping rule.

Keep one record per active call

Most implementations use a call stack. Each active call has a frame recording its parameter values, automatic local variables, and where to continue in the caller. The standard specifies the behavior without requiring this particular memory layout.

If main calls print_table, and print_table calls c_to_f, the converter returns first. Execution resumes inside print_table, which later returns to main. Ordinary automatic locals belong to one call. A static local is different: all calls share its one stored value.

Follow a recursive calculation down

A recursive function calls itself on a smaller problem. A base case returns directly; a recursive case moves toward it.

int factorial(int n)
{
    if (n <= 1)
        return 1;
    return n * factorial(n - 1);
}

For factorial(4), the first call cannot finish its multiplication until factorial(3) returns. That call waits for factorial(2), which waits for factorial(1).

There are four active factorial calls at the deepest point. Each has its own n; reaching n == 1 does not change the earlier calls' values.

Follow the returns up

The base call returns 1. The call with n == 2 now computes 2 * 1 and returns 2. The next returns 3 * 2, or 6; the first returns 4 * 6, or 24. Fill return values into a trace on the way back up, after the called function's result is known.

The stopping condition must be reachable for the supported inputs. If the test were n == 1, starting at zero would keep calling with -1, -2, and lower values instead of reaching one. Continuing recursion exhausts resources and can crash. The broader n <= 1 test stops these inputs, though the mathematical factorial is used for nonnegative integers.

Check both the depth and the result type

Stopping correctly does not guarantee that the result fits. On a platform with a 32-bit int, the largest value is 2147483647. factorial(12) gives 479001600, which fits; factorial(13) would need 6227020800, which does not. Signed integer overflow has undefined behavior.

A loop can compute factorial while keeping one running product in one function call. Recursion is useful when the next problem has the same structure at a smaller size. For positive integers, summing digits is another example: sum_digits(472) needs 2 + sum_digits(47), then 2 + 7 + sum_digits(4), giving 13. A trace should show both the shrinking input and the later combination of returned values.

Scope is the part of the source where a name can be used. Read the braces and declarations to work out which variable an expression names; the order of calls does not change these rules.

Find the scope boundary

A variable declared inside a block has block scope, starting just after its declarator and ending at that block's closing brace. Parameters are visible within their function bodies. A declaration in a for header, such as for (int i = 0; i < 10; i++), makes i available through that loop, but not after it.

A name declared outside all functions has file scope, from its declaration to the end of the translation unit. Functions above that declaration need an earlier declaration to use it. A parameter name in a prototype has prototype scope, ending with the prototype. Thus double c_to_f(double c); can be followed by a definition that names the parameter degrees.

Trace shadowing from the inside out

#include <stdio.h>

int x = 10;

void show(void)
{
    printf("%d\n", x);
}

int main(void)
{
    int x = 5;
    {
        int x = 1;
        printf("%d\n", x);
    }
    printf("%d\n", x);
    show();
    return 0;
}

The inner print uses 1, the next uses 5, and show prints 10. The nearest visible declaration of x wins. Leaving the inner block reveals the outer local again. Calling show does not make main's local visible inside it: show was defined where the file-scope x is visible.

Different functions may each declare a local i, count, or result. These are different variables because their declarations belong to different blocks.

Declare a value where its later uses can see it

This code fails to compile:

if (temp > 30.0) {
    int warning = 1;
}
printf("%d", warning);

The print is outside warning's scope. If the value must be used afterward, declare and initialize it before the conditional:

int warning = 0;
if (temp > 30.0) {
    warning = 1;
}
printf("%d", warning);

Initialization also supplies the value for the path where the condition is false.

Avoid an accidental new variable

Declaring int total = 0; inside a loop creates a new local each time its block is entered. If you intended to accumulate into an outer total, use an assignment such as total += value;. Enable -Wshadow to help find hidden names.

Scope starts before the initializer is evaluated. Inside a block, int x = x + 1; reads the new, uninitialized x, even if an outer x exists. Use a different name if the initializer needs the outer value.

Scope describes where a name is visible in source code. Storage duration describes how long its object exists while the program runs. A static local has block scope while its stored value exists for the entire run.

Storage duration describes how long a variable's storage exists. Use automatic variables for work belonging to one call and static storage when a value must survive between calls.

Compare a fresh value with a remembered value

Parameters and ordinary block-scope variables have automatic storage duration. Each function call gets its own instances. A declaration without an initializer, such as int sum;, supplies no usable starting value. Initialize an accumulator before reading it: int sum = 0;.

File-scope variables and block-scope variables declared static have static storage duration. They exist for the entire program run. Initialization happens once before program startup; absent an explicit initializer, numeric objects start at zero.

int next_ticket(void)
{
    static int n = 0;
    n++;
    return n;
}

Three calls in separate statements return 1, 2, and 3. The initializer does not run again at function entry. Removing static creates a fresh automatic n = 0 for each call, so all three calls return 1.

The name n still has block scope. Other functions cannot name it directly. Recursive calls share the same static local too; they do not receive separate static copies as they do with automatic locals.

Initialize once, assign when needed

A static numeric initializer must be a constant expression in C. static int limit = 12; is valid; static int limit = read_sensor(); is invalid. Perform a runtime assignment in executable code when a value must come from a call. A statement such as n = 0; runs whenever execution reaches it, so placing it at the start of next_ticket would reset the counter on every call.

Read the storage-class specifiers

Modern compilers choose register allocation themselves, so writing register rarely improves code. auto int x; means the same as an ordinary local int x; in C17. C23 also permits type inference with auto x = 3.5;, which declares a double.

C17 also has _Thread_local, spelled thread_local in C23, for thread storage. The grammar groups typedef with storage-class specifiers even though it names a type instead of choosing storage. In C17, only one storage-class specifier normally appears in a declaration; _Thread_local can also accompany static or extern.

A block-scope extern int count; does not create an automatic local copy. It declares an object with linkage and static storage duration. Always consider where the declaration appears before deciding what a storage-class keyword does.

A global variable is declared at file scope, outside every function. It retains a value for the whole run and can give several functions access to shared state.

Follow the shared object

#include <stdio.h>

double total_km = 0.0;

void add_trip(double km)
{
    total_km += km;
}

int main(void)
{
    add_trip(12.5);
    add_trip(7.25);
    printf("%.2f\n", total_km);
    return 0;
}

Both calls update the same object, producing 19.75. The parameter km is still a copy; the function separately assigns to a global it can name. Pass by value does not prevent that assignment.

Globals have static storage duration. Numeric globals default to zero and require constant-expression initializers: int error_count; starts at 0, and double limit = 2.5 * 4; starts at 10.0.

Check visibility and shadowing

A global name is visible only below its declaration. A function above the definition needs an earlier declaration, such as extern double total_km;.

If add_trip instead contains:

double total_km = 0.0;
total_km += km;

it creates and updates a local object. The global stays unchanged. Remove the extra declaration to update the shared total; -Wshadow helps identify accidental hiding.

Make inputs explicit when sharing is unnecessary

A shared error counter can be useful when several functions report failures. But a calculation reading a global has an input absent from its parameter list. Tests must arrange that state, and tracing a wrong value requires finding its possible writers.

An alternative for the trip calculation is:

double with_trip(double total, double km)
{
    return total + km;
}

The caller uses total = with_trip(total, 12.5);. A test supplies both inputs directly, without any global setup.

Restrict shared names

Ordinary file-scope variables have external linkage. Share one through declarations and one definition; repeated definitions across files break that arrangement. File-scope static instead gives internal linkage, allowing another file to have its own independent same-named object. Both objects still last the whole run: the keyword limits linkage here, not lifetime.

The preprocessor transforms source text before the compiler checks C expressions and types. Its directives begin with #. Inspect its output with gcc -E file.c when an inclusion or macro expansion is hard to explain.

Include declarations and name constants

#include <stdio.h> inserts a standard header. Use #include "convert.h" for a project header: GCC first searches the including file's directory, then its configured header paths. The option -Iinclude adds a search directory. Inclusion copies header text; it does not link compiled functions.

An object-like macro substitutes tokens:

#define MAX_STUDENTS 30

Later uses of the token MAX_STUDENTS become 30. The preprocessor leaves the string "MAX_STUDENTS" and the different name MAX_STUDENTS_2 alone. Write no = and no trailing semicolon. With #define PI 3.14159;, return PI * r * r; expands to the broken code return 3.14159; * r * r;. A directive normally ends at the newline; a final backslash continues it.

Expand before calculating

A function-like macro has no space between its name and opening parenthesis:

#define SQUARE_BAD(x) x * x
#define SQUARE(x) ((x) * (x))

SQUARE_BAD(2 + 3) becomes 2 + 3 * 2 + 3, which evaluates to 11. 100 / SQUARE_BAD(5) becomes 100 / 5 * 5, giving 100. The grouped macro gives 25 and 4 respectively. Parenthesize each parameter and the whole replacement expression so surrounding operators cannot change its grouping.

Writing #define SQUARE (x) ((x) * (x)) instead makes an object-like macro whose replacement begins with (x). The space changes the definition's meaning.

Parentheses do not prevent repeated evaluation

SQUARE(i++) expands to ((i++) * (i++)). It modifies i twice without sequencing, so behavior is undefined. A real function such as square(i++) evaluates the argument once before entering the body. Prefer functions for calculations, especially when an input expression changes state.

A function-like macro has no declared parameter or return types. Its expanded C code is still type-checked, but it has no prototype specifying argument conversions. Macros remain useful for include guards, conditional compilation, and integer constant expressions. In C17, a const int variable is not an integer constant expression; a macro or an enum constant can supply a case value. C23 also introduces constexpr.

Turn arguments into tokens or text

#define SHOW(expr) printf(#expr " = %d\n", expr)
#define CAT(a, b) a##b

SHOW(3 + 4); uses # to turn the argument into text and prints 3 + 4 = 7. CAT(temp, 1) uses ## to join tokens into the name temp1. Stringification uses the supplied argument tokens without expanding macros inside that occurrence; an ordinary occurrence of the argument is expanded.

Macros do not follow block scope. A definition remains active until #undef NAME or the end of the translation unit, even if the directive was written between braces. Remove an old definition with #undef before giving it different replacement text.

Conditional compilation selects which source lines reach the compiler. It can enable debug output, choose platform code, or protect a header against repeated inclusion.

Test existence or test a value

#define DEBUG 0

#ifdef DEBUG
/* Kept: DEBUG exists. */
#endif

#if DEBUG
/* Removed: DEBUG expands to zero. */
#endif

#ifdef DEBUG asks whether the macro is defined. #if DEBUG evaluates its replacement value as an integer constant expression. Inside #if, an undefined identifier counts as zero; a misspelled macro can silently remove a branch. The expressions defined DEBUG and defined(DEBUG) both test existence.

Use #ifndef NAME for the opposite existence test. Close every conditional with #endif. #elif adds another condition and #else supplies the fallback. C23 adds #elifdef and #elifndef; C17 can express those tests using #elif defined(NAME) or #elif !defined(NAME).

Choose the setting at build time

#ifdef DEBUG
printf("debug: c = %.1f\n", c);
#endif

gcc -std=c17 -DDEBUG main.c defines DEBUG as 1 and keeps the print. Without that definition, the line is removed before compilation. -DLEVEL=2 supplies a value as if #define LEVEL 2 appeared before the file's text.

This differs from an ordinary if, whose condition is evaluated when the program runs. Preprocessor conditions cannot read an ordinary runtime variable. #if 0 removes a block, including code with existing /* */ comments that would make wrapping it in another such comment unsafe.

Guard a header

#ifndef CONVERT_H
#define CONVERT_H

double c_to_f(double c);

#endif

The first inclusion defines CONVERT_H and keeps the prototype. Later inclusions in that same translation unit skip the contents. Use a distinct guard name based on the header name; avoid leading underscores reserved for the implementation. Another translation unit begins its own preprocessing run and includes the declarations for itself. A guard does not stop different object files from defining the same external symbol.

Many compilers support #pragma once, but it is not an ISO C directive. Guards work with standard conditional directives.

Read the predefined information

Version values include 199901L for C99, 201112L for C11, 201710L for C17, and 202311L for C23. __func__ holds the current function name, but is a predefined identifier, not a macro.

A platform branch can test defined(_WIN32) or defined(__linux__), then use #else for a fallback. To reject an unsupported build explicitly, write a condition followed by #error "This program needs C11 or later" and #endif. An omitted #endif instead produces a directive error such as "unterminated conditional directive".

Separate compilation turns each source file into an object file before linking the program. This lets a build reuse unchanged object files and gives related functions a clear place to live.

Follow the build stages

A translation unit is one .c file after preprocessing, including the contents of its included headers. Each unit is compiled independently.

An object file contains machine code and symbol information about names it defines or needs. On Unix-like systems it usually has the suffix .o. The linker connects external name uses to definitions supplied by object files and libraries.

Compile two files and link them

Suppose convert.h declares double c_to_f(double c);, convert.c includes that header and defines the function, and main.c includes the header and calls it.

gcc -Wall -Wextra -std=c17 -c main.c
gcc -Wall -Wextra -std=c17 -c convert.c
gcc main.o convert.o -o temp

The first command produces main.o without linking. The second produces convert.o. The last makes the executable temp from both objects. You can also compile and link in one command:

gcc -Wall -Wextra -std=c17 main.c convert.c -o temp

Pass the source files for compilation and the object files for linking. Headers enter through #include; do not list them as separately compiled program sources. If only convert.c changes, reuse main.o, rebuild convert.o, and link again. If a shared header changes, rebuild every object whose source includes it.

Diagnose the stage that failed

A compile error concerns a translation unit: invalid syntax, a wrong argument count, or conflicting visible types. The linker cannot repair these.

A link error concerns the assembled program. If you build only main.c, the prototype can make compilation succeed while linking reports "undefined reference to c_to_f" or "Undefined symbols". The declaration promises a function; it does not supply its machine code. Add convert.c to a combined build, or convert.o to the link.

Two linked external definitions of the same function cause a duplicate-symbol error. The ordinary program has one main; linking two sources that both define it fails. File-private static functions can have matching names in different translation units because they have internal linkage.

Libraries also supply definitions. On many Linux systems, code using functions declared by <math.h> needs a math-library link option: gcc main.c -o app -lm. Keep that library option after the code that needs it.

Include the interface, compile the implementation

Avoid #include "convert.c". That copies function bodies into another translation unit. If convert.c is also compiled and linked, its external definitions appear twice. A module's .h file shares its declarations; its .c file is compiled once as a source file.

A module's header shares its interface; its source supplies the implementation. Both callers and the implementation include the header so their declarations agree.

Declare the interface once

A guarded convert.h contains:

#ifndef CONVERT_H
#define CONVERT_H

double c_to_f(double c);
double f_to_c(double f);

#endif

The implementation in convert.c includes it before the bodies:

#include "convert.h"

double c_to_f(double c)
{
    return c * 9.0 / 5.0 + 32.0;
}

double f_to_c(double f)
{
    return (f - 32.0) * 5.0 / 9.0;
}

A caller includes the same header and <stdio.h>. The call printf("%.1f %.1f\n", c_to_f(25.0), f_to_c(212.0)); prints 77.0 100.0.

If the implementation defines float c_to_f(float c), including its header exposes the conflicting types to the compiler. Independent compilation without that declaration can miss the disagreement.

Choose the right contents

A header containing int count = 0; defines an object in every including translation unit, causing duplicate external definitions. Even int count; is a tentative definition. GCC's default since version 10 diagnoses repeated copies at link time, while some toolchains merge common symbols and hide the bug. Use extern int count; in the header and one definition in a source.

Make inclusion reliable

A guard prevents repeated processing within a translation unit, including indirect inclusion through other headers. Compatible prototypes can repeat, but type definitions such as an enum can cause redefinition errors.

A self-contained header includes what its declarations need. If a prototype uses size_t, include <stddef.h> there. Callers should not need a special include order.

For project headers, quotes search the including file's directory first with GCC. Add a separate header directory with -Iinclude, as in gcc -Iinclude -std=c17 -c src/main.c. The implementation's object still needs to be linked.

Linkage determines whether declarations in different places refer to the same entity. It is separate from scope, which describes where a name can be used, and storage duration, which describes how long an object exists.

Connect one name to one object

Functions and ordinary file-scope variables have external linkage by default. File-scope static gives internal linkage. Ordinary automatic locals and parameters have no linkage.

To share one error counter, put these declarations in a guarded header:

extern int error_count;
void log_error(int code);

One source file includes that header and supplies:

int error_count = 0;

void log_error(int code)
{
    printf("error: %d\n", code);
    error_count++;
}

That source also includes <stdio.h> for printf. Other source files include the shared header, not a second definition. After three calls, every caller reading error_count refers to the same object and sees 3.

Distinguish declaration from definition

extern int error_count; declares an existing object and allocates no new storage. int error_count = 0; defines it. An initializer changes the case: at file scope, extern int error_count = 0; is a definition despite the keyword. Keep the initializer in the one defining file.

On ordinary public function declarations, extern is optional: double c_to_f(double c); already declares a function with external linkage. Include the public declaration in its defining file so the compiler can check compatibility.

Hide state behind functions

static int count = 0;

void counter_increment(void)
{
    count++;
}

int counter_value(void)
{
    return count;
}

The stored value exists for the whole run, but only this translation unit can refer to it by the name count. Put the public function prototypes in a header. Another file can increment and read the counter through those functions without directly changing the private variable. A helper function can also be static when other files do not need it.

Diagnose a mistaken linkage choice

A static int count; definition in a header creates an independent private counter in each including translation unit. Updating one does not update the others. Include guards do not merge these objects: each translation unit preprocesses its own header copy.

A function defined static in one translation unit cannot satisfy an external call from another; linking fails for that external name. Give only functions that other files need external linkage, and declare those in the header.

Inside a function, static gives a local variable retained storage without widening its scope. Outside functions, it gives an object or function internal linkage. File-scope variables have static storage duration with or without that keyword.

make reads Makefile or makefile in the project directory and updates the requested target. Without a target argument, it normally builds the first ordinary target.

Record outputs and inputs

A rule starts with target: prerequisites. Its recipe is either on following tab-indented lines or after a semicolon on the same line:

CC = gcc
CFLAGS = -Wall -Wextra -std=c17 -g

temp: main.o convert.o; $(CC) $(CFLAGS) -o temp main.o convert.o

main.o: main.c convert.h; $(CC) $(CFLAGS) -c main.c

convert.o: convert.c convert.h; $(CC) $(CFLAGS) -c convert.c

.PHONY: clean
clean:; rm -f temp main.o convert.o

Here temp is the default goal. make clean requests the cleanup action. If writing a recipe on the next line, use a literal tab: spaces can cause "missing separator". An editor's visible-whitespace setting helps spot the difference.

Trace the rebuild decisions

Make updates a target's prerequisites first. It then rebuilds the target if it is absent or any prerequisite has a newer modification time.

• First build: compile both sources, then link temp—three commands.
• No changes: no program recipes need to run.
• Edit only convert.c: recompile it and relink—two commands; reuse main.o.
• Edit convert.h: recompile both sources and relink—three commands.

The header affects both translation units, even though neither source was edited. Picture input files feeding objects, then objects feeding the executable. Changes propagate through those recorded relationships.

Include header dependencies

The incomplete rule main.o: main.c misses edits to convert.h. Make does not read C source to discover includes; it follows declared prerequisites. List included headers or load compiler-generated dependency files to avoid linking stale objects.

Keep dependent shell operations together

Separate recipe lines normally use separate shells. A line containing only cd build does not change the directory for the next line. Use one command such as cd build && gcc -c ../main.c when the compile depends on that directory change. Preview planned recipes with make -n.

Variables and pattern rules remove repeated compiler commands while preserving the dependency graph. The examples place each recipe after a semicolon on its rule line. Shorten a makefile only after its build relationships are correct.

Name shared settings

CC = gcc
CFLAGS = -Wall -Wextra -std=c17 -g
OBJS = main.o convert.o

temp: $(OBJS); $(CC) $(CFLAGS) -o $@ $^

%.o: %.c convert.h; $(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

.PHONY: clean
clean:; rm -f temp $(OBJS)

$(CC) expands the compiler variable; $(CFLAGS) expands its flags. CPPFLAGS conventionally holds preprocessor options such as -DDEBUG or -Iinclude. The flags -Wall -Wextra enable warnings, -g adds debugging information, and -O2 enables optimization. Undefined make variables expand to empty text. Write $(CC), not $CC: the latter means the one-letter variable C, followed by a literal C.

Read automatic variables inside a rule

For main.o, the pattern's stem is main, so %.c becomes main.c. The compile recipe uses $< to pass that source to the compiler, and $@ to name main.o. The header is a dependency, but is not passed as another compilation input.

In the link rule, all prerequisites are object files. $^ expands to main.o convert.o, and $@ becomes temp. Using $< there would pass only main.o, losing the definitions in convert.o.

GNU make has built-in rules that can compile x.c to x.o using CC, CPPFLAGS, and CFLAGS. An explicit dependency rule without a recipe can use that built-in recipe. GNU make can even build a simple program with make hello from hello.c without a makefile.

Mark action targets as phony

clean names an action, not a file to create. .PHONY: clean ensures the action runs even if a file named clean exists. rm -f tolerates files already being absent. An all target that groups several programs is usually phony too.

Generate header lists and inspect rebuilds

Add -MMD -MP to compile flags to write a .d file alongside each object. -MMD records user-header dependencies; -MP adds empty rules that help when a recorded header is removed. After the ordinary default target, load the lists with:

-include $(OBJS:.o=.d)

The substitution turns object names into dependency-file names. The leading minus tolerates missing .d files on the first build. Remove these generated files in clean along with the objects.

make -n previews commands, make -B forces rebuilding, and make -j4 permits up to four recipes at once. Correct dependencies matter for parallel builds too. Changing CFLAGS text alone does not make existing objects older than a prerequisite. After changing flags, use make -B or a clean rebuild so every object uses the new settings.