How to make a SIMPLE C++ Makefile

Since this is for Unix, the executables don’t have any extensions.

One thing to note is that root-config is a utility which provides the right compilation and linking flags; and the right libraries for building applications against root. That’s just a detail related to the original audience for this document.

Make Me Baby

or You Never Forget The First Time You Got Made

An introductory discussion of make, and how to write a simple makefile

What is Make? And Why Should I Care?

The tool called Make is a build dependency manager. That is, it takes care of knowing what commands need to be executed in what order to take your software project from a collection of source files, object files, libraries, headers, etc., etc.—some of which may have changed recently—and turning them into a correct up-to-date version of the program.

Actually, you can use Make for other things too, but I’m not going to talk about that.

A Trivial Makefile

Suppose that you have a directory containing: tool tool.cc tool.o support.cc support.hh, and support.o which depend on root and are supposed to be compiled into a program called tool, and suppose that you’ve been hacking on the source files (which means the existing tool is now out of date) and want to compile the program.

To do this yourself you could

  1. Check if either support.cc or support.hh is newer than support.o, and if so run a command likeg++ -g -c -pthread -I/sw/include/root support.cc
  2. Check if either support.hh or tool.cc are newer than tool.o, and if so run a command likeg++ -g -c -pthread -I/sw/include/root tool.cc
  3. Check if tool.o is newer than tool, and if so run a command likeg++ -g tool.o support.o -L/sw/lib/root -lCore -lCint -lRIO -lNet -lHist -lGraf -lGraf3d -lGpad -lTree -lRint \ -lPostscript -lMatrix -lPhysics -lMathCore -lThread -lz -L/sw/lib -lfreetype -lz -Wl,-framework,CoreServices \ -Wl,-framework,ApplicationServices -pthread -Wl,-rpath,/sw/lib/root -lm -ldl

Phew! What a hassle! There is a lot to remember and several chances to make mistakes. (BTW– the particulars of the command lines exhibited here depend on our software environment. These ones work on my computer.)

Of course, you could just run all three commands every time. That would work, but it doesn’t scale well to a substantial piece of software (like DOGS which takes more than 15 minutes to compile from the ground up on my MacBook).

Instead you could write a file called makefile like this:

tool: tool.o support.o
    g++ -g -o tool tool.o support.o -L/sw/lib/root -lCore -lCint -lRIO -lNet -lHist -lGraf -lGraf3d -lGpad -lTree -lRint \
        -lPostscript -lMatrix -lPhysics -lMathCore -lThread -lz -L/sw/lib -lfreetype -lz -Wl,-framework,CoreServices \
        -Wl,-framework,ApplicationServices -pthread -Wl,-rpath,/sw/lib/root -lm -ldl

tool.o: tool.cc support.hh
    g++ -g  -c -pthread -I/sw/include/root tool.cc

support.o: support.hh support.cc
    g++ -g -c -pthread -I/sw/include/root support.cc

and just type make at the command line. Which will perform the three steps shown above automatically.

The unindented lines here have the form “target: dependencies” and tell Make that the associated commands (indented lines) should be run if any of the dependencies are newer than the target. That is, the dependency lines describe the logic of what needs to be rebuilt to accommodate changes in various files. If support.cc changes that means that support.o must be rebuilt, but tool.o can be left alone. When support.o changes tool must be rebuilt.

The commands associated with each dependency line are set off with a tab (see below) should modify the target (or at least touch it to update the modification time).

Variables, Built In Rules, and Other Goodies

At this point, our makefile is simply remembering the work that needs doing, but we still had to figure out and type each and every needed command in its entirety. It does not have to be that way: Make is a powerful language with variables, text manipulation functions, and a whole slew of built-in rules which can make this much easier for us.

Make Variables

The syntax for accessing a make variable is $(VAR).

The syntax for assigning to a Make variable is: VAR = A text value of some kind (or VAR := A different text value but ignore this for the moment).

You can use variables in rules like this improved version of our makefile:

CPPFLAGS=-g -pthread -I/sw/include/root
LDFLAGS=-g
LDLIBS=-L/sw/lib/root -lCore -lCint -lRIO -lNet -lHist -lGraf -lGraf3d -lGpad -lTree -lRint \
       -lPostscript -lMatrix -lPhysics -lMathCore -lThread -lz -L/sw/lib -lfreetype -lz \
       -Wl,-framework,CoreServices -Wl,-framework,ApplicationServices -pthread -Wl,-rpath,/sw/lib/root \
       -lm -ldl

tool: tool.o support.o
    g++ $(LDFLAGS) -o tool tool.o support.o $(LDLIBS)

tool.o: tool.cc support.hh
    g++ $(CPPFLAGS) -c tool.cc

support.o: support.hh support.cc
    g++ $(CPPFLAGS) -c support.cc

which is a little more readable, but still requires a lot of typing

Make Functions

GNU make supports a variety of functions for accessing information from the filesystem or other commands on the system. In this case we are interested in $(shell ...) which expands to the output of the argument(s), and $(subst opat,npat,text) which replaces all instances of opat with npat in text.

Taking advantage of this gives us:

CPPFLAGS=-g $(shell root-config --cflags)
LDFLAGS=-g $(shell root-config --ldflags)
LDLIBS=$(shell root-config --libs)

SRCS=tool.cc support.cc
OBJS=$(subst .cc,.o,$(SRCS))

tool: $(OBJS)
    g++ $(LDFLAGS) -o tool $(OBJS) $(LDLIBS)

tool.o: tool.cc support.hh
    g++ $(CPPFLAGS) -c tool.cc

support.o: support.hh support.cc
    g++ $(CPPFLAGS) -c support.cc

which is easier to type and much more readable.

Notice that

  1. We are still stating explicitly the dependencies for each object file and the final executable
  2. We’ve had to explicitly type the compilation rule for both source files

Implicit and Pattern Rules

We would generally expect that all C++ source files should be treated the same way, and Make provides three ways to state this:

  1. suffix rules (considered obsolete in GNU make, but kept for backwards compatibility)
  2. implicit rules
  3. pattern rules

Implicit rules are built in, and a few will be discussed below. Pattern rules are specified in a form like

%.o: %.c
    $(CC) $(CFLAGS) $(CPPFLAGS) -c $<

which means that object files are generated from C source files by running the command shown, where the “automatic” variable $< expands to the name of the first dependency.

Built-in Rules

Make has a whole host of built-in rules that mean that very often, a project can be compile by a very simple makefile, indeed.

The GNU make built in rule for C source files is the one exhibited above. Similarly we create object files from C++ source files with a rule like $(CXX) -c $(CPPFLAGS) $(CFLAGS).

Single object files are linked using $(LD) $(LDFLAGS) n.o $(LOADLIBES) $(LDLIBS), but this won’t work in our case, because we want to link multiple object files.

Variables Used By Built-in Rules

The built-in rules use a set of standard variables that allow you to specify local environment information (like where to find the ROOT include files) without re-writing all the rules. The ones most likely to be interesting to us are:

  • CC — the C compiler to use
  • CXX — the C++ compiler to use
  • LD — the linker to use
  • CFLAGS — compilation flag for C source files
  • CXXFLAGS — compilation flags for C++ source files
  • CPPFLAGS — flags for the c-preprocessor (typically include file paths and symbols defined on the command line), used by C and C++
  • LDFLAGS — linker flags
  • LDLIBS — libraries to link

A Basic Makefile

By taking advantage of the built-in rules we can simplify our makefile to:

CC=gcc
CXX=g++
RM=rm -f
CPPFLAGS=-g $(shell root-config --cflags)
LDFLAGS=-g $(shell root-config --ldflags)
LDLIBS=$(shell root-config --libs)

SRCS=tool.cc support.cc
OBJS=$(subst .cc,.o,$(SRCS))

all: tool

tool: $(OBJS)
    $(CXX) $(LDFLAGS) -o tool $(OBJS) $(LDLIBS)

tool.o: tool.cc support.hh

support.o: support.hh support.cc

clean:
    $(RM) $(OBJS)

distclean: clean
    $(RM) tool

We have also added several standard targets that perform special actions (like cleaning up the source directory).

Note that when make is invoked without an argument, it uses the first target found in the file (in this case all), but you can also name the target to get which is what makes make clean remove the object files in this case.

We still have all the dependencies hard-coded.

Some Mysterious Improvements

CC=gcc
CXX=g++
RM=rm -f
CPPFLAGS=-g $(shell root-config --cflags)
LDFLAGS=-g $(shell root-config --ldflags)
LDLIBS=$(shell root-config --libs)

SRCS=tool.cc support.cc
OBJS=$(subst .cc,.o,$(SRCS))

all: tool

tool: $(OBJS)
    $(CXX) $(LDFLAGS) -o tool $(OBJS) $(LDLIBS)

depend: .depend

.depend: $(SRCS)
    $(RM) ./.depend
    $(CXX) $(CPPFLAGS) -MM $^>>./.depend;

clean:
    $(RM) $(OBJS)

distclean: clean
    $(RM) *~ .depend

include .depend

Notice that

  1. There are no longer any dependency lines for the source files!?!
  2. There is some strange magic related to .depend and depend
  3. If you do make then ls -A you see a file named .depend which contains things that look like make dependency lines

Other Reading

  • GNU make manual
  • Recursive Make Considered Harmful on a common way of writing makefiles that is less than optimal, and how to avoid it.

Know Bugs and Historical Notes

The input language for Make is whitespace sensitive. In particular, the action lines following dependencies must start with a tab. But a series of spaces can look the same (and indeed there are editors that will silently convert tabs to spaces or vice versa), which results in a Make file that looks right and still doesn’t work. This was identified as a bug early on, but (the story goes) it was not fixed, because there were already 10 users.

(This was copied from a wiki post I wrote for physics graduate students.)

Related Posts:

  1. Difference between using Makefile and CMake to compile the code
  2. Cygwin Make bash command not found
  3. What is the job of autogen.sh when building a c++ package on Linux
  4. Using G++ to compile multiple .cpp and .h files
  5. “No rule to make target ‘install'”… But Makefile exists
  6. Make / gcc cryptic error 2: how to have more information?
  7. Linker error: “linker input file unused because linking not done”, undefined reference to a function in that file
  8. How many spaces for tab character(\t)?
  9. How do I build a graphical user interface in C++? [closed]
  10. What are the differences between a pointer variable and a reference variable in C++?
  11. outputting ascii table in C++
  12. What is the effect of extern “C” in C++?
  13. What exactly is the difference between “pass by reference” in C and in C++?
  14. rand() between 0 and 1
  15. how to implement Interfaces in C++?
  16. What exactly is nullptr?
  17. How to fix C++ error: expected unqualified-id
  18. How to track down a “double free or corruption” error
  19. Error: “expression must have integral or unscoped enum type” [duplicate]
  20. How to fix C++ error: expected unqualified-id
  21. Reading from file in c++ ifstream
  22. How do I iterate over the words of a string?
  23. C++ IDE for Macs
  24. C++ Error: No match for ‘operator=’
  25. How to fix ‘No match for operator[]’ error (c++)
  26. std::cin.getline( ) vs. std::cin
  27. C++ error: terminate called after throwing an instance of ‘std::bad_alloc’
  28. Is there a decent wait function in C++?
  29. streambuf::xsgetn and state flags
  30. C++ table alignment – cout and iomanip
  31. Debug assertion failed. C++ vector subscript out of range
  32. Inheriting constructors
  33. Vector is not a Template?
  34. Displaying a vector of strings in C++
  35. ‘vector’ in namespace ‘std’ does not have a template type
  36. Floating Point Exception C++ Why and what is it?
  37. Issue with std::stol – ‘std::invalid_argument’ what(): stol
  38. Writing a LinkedList destructor?
  39. VC++ fatal error LNK1168: cannot open filename.exe for writing
  40. Creating a copy constructor for a linked list
  41. Is there a tab equivalent of std::endl within the standard library?
  42. Is the practice of returning a C++ reference variable evil?
  43. Is there ‘byte’ data type in C++?
  44. How to return a string from a C++ function?
  45. C++, random number w/ range of 1-6
  46. What does “missing template argument” mean?
  47. How do conversion operators work in C++?
  48. What is the difference between isdigit() and isnumber()?
  49. Convert char* to string C++
  50. C++ delete vector, objects, free memory
  51. Undefined reference to constructor
  52. Copy a file in a sane, safe and efficient way
  53. c++ convert string to hex
  54. LINK : fatal error LNK1561: entry point must be defined ERROR IN VC++
  55. Multiple OR or AND conditions in IF statement
  56. What does it mean double free detected in tcache 2 while using mpz?
  57. fatal error LNK1169: one or more multiply defined symbols found in game programming
  58. expression did not evaluate to a constant- c++
  59. Generate SHA256 in c++
  60. A good and basic implementation of BigInt class in C++
  61. What is the C equivalent to the C++ cin statement?
  62. c++ Read from .csv file
  63. Check if C++ Array is Null
  64. Random not declared in scope
  65. What does the “Expected ‘(‘ for function-style cast or type construction” error mean?
  66. LINK : fatal error LNK1561: entry point must be defined ERROR IN VC++
  67. Comparing the values of char arrays in C++
  68. Win32 Console Application
  69. How do I create a random alpha-numeric string in C++?
  70. Learning to work with audio in C++
  71. Creating an instance of class
  72. Destructor for a doubly-linked list that points to its value
  73. cin.ignore(numeric_limits::max(), ‘\n’)
  74. LLVM Compiler 2.0: Warning with “using namespace std;”
  75. C++ operator+ and operator+= overloading
  76. In c++ what does a tilde “~” before a function name signify?
  77. System not declared in scope?
  78. no debugging symbols found when using gdb
  79. C++ Array of pointers: delete or delete []?
  80. ERROR: Control may reach end of non-void function /
  81. Function stoi not declared
  82. What’s the difference between while(cin) and while(cin >> num)
  83. Too many arguments to function
  84. not declared in this scope’ when using strlen()
  85. Converting a Cubemap into Equirectangular Panorama
  86. Why is this vector iterator not incrementable?
  87. glibc detected : double free or corruption
  88. What is the best way to develop a C++ web application?
  89. How to install Visual Studio Build Tools 2010 on Visual Studio 2015 Community?
  90. Throwing out of range exception in C++
  91. error LNK2019: unresolved external symbol _WinMain@16 referenced in function ___tmainCRTStartup
  92. Displaying contents of a vector container in C++
  93. Converting string to unsigned int returns the wrong result
  94. Visual c++ can’t open include file ‘iostream’
  95. c++ vector bubble sort
  96. compare and swap vs test and set
  97. Weighted random numbers
  98. compare and swap vs test and set
  99. Link error “undefined reference to `__gxx_personality_v0′” and g++ [duplicate]
  100. How to use bitmask?

Leave a Comment