How to Make a Makefile for a C Program

When it comes to managing and building complex software projects, a makefile is an essential tool. In this article, we will explore the process of creating a makefile for a C program and provide a real-world example to illustrate how it works.

Before we dive into the details, let's start with a brief overview of what a makefile is. A makefile is a text file that contains instructions on how to build and compile a software project. It uses a simple scripting language to specify dependencies between different files in the project and determines which files need to be rebuilt when changes are made.

Project #1: Creating a Makefile for Generating Binary, Shared Object, and Static Object

The first project we will tackle is creating a makefile that generates a binary file, shared object (so), and static object (a). This will give you a basic understanding of how to create a makefile and how it can be used to build different types of files.

To start, open up your favorite text editor and create a new file. Name this file 'Makefile' and add the following code:

```

CC=gcc

CFLAGS=-c -Wall

all: main

main: main.o

$(CC) $(CFLAGS) main.o -o main

main.o: main.c

$(CC) $(CFLAGS) main.c -o main.o

clean:

rm -f *o main

```

Let's break down this code:

* The first line, `CC=gcc`, sets the compiler to use when building the project. In this case, we are using the GNU C Compiler (gcc).

* The second line, `CFLAGS=-c -Wall`, specifies the flags that will be passed to the compiler. The `-c` flag tells the compiler to compile but not link, and the `-Wall` flag turns on all warnings.

* The third line, `all: main`, specifies the target of our makefile. In this case, we are building a single target called 'main'.

* The fourth line, `main: main.o`, specifies that the 'main' target depends on the 'main.o' object file. The `$CC` variable is used to call the compiler with the flags specified in the `CFLAGS` variable.

* The fifth line, `main.o: main.c`, specifies that the 'main.o' object file depends on the 'main.c' source file.

* The final line, `clean: rm -f *o main`, specifies a clean target that removes all object files and the binary.

To use this makefile, simply navigate to the directory containing your Makefile and type `make` at the command prompt. This will build the project and generate the necessary files.

Project #2: Understanding Make Tool & Writing Better Makefiles

In the second part of our journey, we will explore how to write better makefiles by understanding what is happening behind the scenes during building C/C++ programs. We will also learn how to create intermediate files and how to use these files to speed up the build process.

Creating Intermediate Files

When building C/C++ programs, the compiler often creates temporary files that are used during the compilation process. These files can be thought of as intermediate files because they are used to generate the final output. In our example makefile, we can add a rule to create an intermediate file called 'main.i' which will contain the preprocessed source code:

```

main.i: main.c

$(CC) -E main.c > main.i

```

This rule uses the `-E` flag to specify that we want to preprocess the source code without compiling it. The output is redirected to a file called 'main.i'.

In this article, we have explored how to create a makefile for a C program and provided two real-world examples of how to use makefiles in your projects. By understanding how makefiles work and how they can be used to build different types of files, you will be able to write better makefiles and speed up the development process.

Remember, practice makes perfect! Try creating your own makefiles for different projects and experiment with different flags and options to see what works best for you.

How to make makefile for c program