An Introduction to Imperative Programming

To successfully build an executable, exactly one contributing translation unit needs to contain a function with the name main. Program execution starts with this function. Unix programs (and, consequently, C programs) can be started with arguments. These are given to the main function in the form of two parameters, argc and argv. argc contains the number of the provided program arguments, including the program name as mandatory first argument. The actual character strings of the arguments are available in the argv array. A character string, usually just called string in C is a null-terminated sequence of characters. Strings are referred to by the address of their first character. argv is therefore an array of pointers to the first character of each argument (see Figure 4.5.2).

For an example, consider a main function that calls the factorial function from the previous section with an argument obtained from the command line.

#include <stdio.h>
#include <stdlib.h>

/* here is the declaration of the factorial function  */

int main(int argc, char *argv[]) {
    if (argc <= 1) {
        fprintf(stderr, "syntax: %s <value>\n",
                argv[0]);
        return 1;
    }

    int n = atoi(argv[1]);
    int r = factorial(n);
    printf("%u\n", r);
    return 0;
}

We build this program with the following commands:

$ cc -o factorial.o -c factorial.c
$ cc -o factorial factorial.o

Then, the following program execution will fail:

$ ./factorial
syntax: ./factorial <value>

The provided message tells us to provide a number whose factorial the program should compute. The following invocation will produce the desired result:

$ ./factorial 5
120

The main function first checks whether an argument was provided. This is the case if the value of argc is greater than 1 (since the program name is always the first parameter.) If no argument was given, the program prints an explanatory message to the user and terminates with the value 1. Otherwise, the first argument (a string of characters) is converted to an integer number and its factorial is computed. The program displays the result via printf and then terminates successfully with the value 0.

Let us assume that we want to separate the main function and the factorial function into different translation units. It is often good practice to bundle functions that are thematically connected, for example because they operate on similar data, into their own translation unit. We usually separate the main function from other functions since it contains mostly argument handling and gives the relevant arguments to the other functions. The factorial function could be reused in a different project where factorials need to be computed; our main function less so. Therefore, it is reasonable to separate the functions into two translation units, which are compiled separately.

#include "factorial.h"

int factorial(int n) {
    int res = 1;
    while (n > 1) {
        res = res * n;
        n   = n - 1;
    }
    return res;
}

#ifndef FACTORIAL_H
#define FACTORIAL_H
int factorial(int n);
#endif /* FACTORIAL_H */

#include <stdio.h>
#include <stdlib.h>

#include "factorial.h"

int main(int argc, char *argv[]) {
    if (argc <= 1) {
        fprintf(stderr,
            "syntax: %s <value>\n",
            argv[0]);
        return 1;
    }

    int n = atoi(argv[1]);
    int r = factorial(n);
    printf("%u\n", r);
    return 0;
}

        int factorial(int);
        

The C preprocessor is a separate program that is invoked by the C compiler before it performs the actual translation. It transforms a text into a new text by expanding preprocessing directives. All preprocessing directives start with a hash sign (#). The directive #include "x.h" for example interrupts the preprocessing of the current file, preprocesses the file x.h, and then resumes preprocessing the original file. As a result, in our example in Figure 4.5.5, the preprocessing inserts the content of factorial.h into both translation units, factorial.c and main.c.

In practice, projects can easily consist of hundreds to thousands of translation units. To avoid building them all by hand, there is the Unix tool make. It operates based on a file with the name Makefile, in which we specify how to build the project. This description contains the dependencies between the involved files and a description how to produce files from their prerequisites.

factorial: factorial.o main.o
	cc -o $@ $^

main.o: main.c factorial.h
factorial.o: factorial.c factorial.h

%.o: %.c
	cc -o $@ -c $<

clean:
	rm -f factorial *.o

The first two lines of the Makefile specify that we need the files factorial.o and main.o to build the file factorial, and that the latter file is built from the former two files with the command cc -o factorial factorial.o main.o. The last two lines determine that any file ending with .o is built from a similarly named file with ending with .c. The command cc -o x.o -c x.c performs this translation.

Usage of make is not restricted to C. It is a general tool to describe build processes and dependencies. It is however most commonly used for C projects.