C++ Makefile that includes ddd debugger option - c++

Question

I'm kind of new to Makefiles and i'm trying to include a debugger option in my makefile that opens the debugger when I type "make debug." However, that command returns an error. I already have the ddd debugger installed in my virtual machine. This is my makefile below. Any help?
main: main.cpp puzzle.cpp fuse.cpp
g++ --std=c++11 -o main main.cpp
./main
clean:
-rm -f *.o main
debug:
g++ --std=c++11 -g debug main.cpp puzzle.cpp fuse.cpp ddd debug

Answer 1

TL;DR
g++ --std=c++11 -g debug main.cpp puzzle.cpp fuse.cpp ddd debug
This line is in error. It tells G++ to compile, using the options --std=c++11 -g, the list of files given -- including "ddd" and "debug" (twice) -- to a.out (or a.exe if you're on Windows / Cygwin).
That is not what you wanted, and as "debug" and "ddd" are unlikely to be valid C++ source files, the compiler run fails.
If you type make debug, then make will execute the debug rule:
debug:
g++ --std=c++11 -g debug main.cpp puzzle.cpp fuse.cpp ddd debug
If no file named debug exists (*), make will attempt to recreate it using the command:
g++ --std=c++11 -g debug main.cpp puzzle.cpp fuse.cpp ddd debug
I don't quite know what you expect that command to do. I guess that you intended two commands to be executed in sequence:
debug:
g++ --std=c++11 -g debug main.cpp puzzle.cpp fuse.cpp
ddd debug
However, the compiler line is in error. I guess you wanted something like this (note the -o):
g++ --std=c++11 -g -o debug main.cpp puzzle.cpp fuse.cpp
main: main.cpp puzzle.cpp fuse.cpp
g++ --std=c++11 -o main main.cpp
./main
This is broken several ways.
This rule instructs make to rebuild main from scratch whenever any of the files main.cpp, puzzle.cpp or fuse.cpp is touched. However, the command you are giving only recompiles main.cpp -- the other two files are never (re)compiled.
A good Makefile rule only does what is needed to (re)build the file it is named by, and is as generic as possible.
For example, to "tell" make how to create a *.o file from any given *.cpp file ($# and #< being placeholder for "target of rule" and "first dependency", respectively):
%.o: %.cpp
g++ --std=c++11 -o $# #<
Once you have that, you can tell make how to build your executable from individual object files ($^ being a placeholder for "all the dependencies"):
main: main.o puzzle.o fuse.o
g++ --std=c++11 -o $# $^
This way, if you touch one of the source files (e.g. puzzle.cpp), only that one object file gets rebuilt, and the main executable relinked. With large projects, this significantly reduces (re)compile times.
(*) If you have rules that do not actually create a file, you should label them as .PHONY, so make will execute them even if a file by that name happens to exist already.
You also usually want to disable optimization for debugging, to avoid some of the stranger things that can happen with optimization on.
So (for easier example compiling with -g debugging information always):
.PHONY: debug
%.o: %.cpp
g++ --std=c++11 -g -O0 -o $# #<
main: main.o puzzle.o fuse.o
g++ --std=c++11 -g -O0 -o $# #^
debug: main
ddd main
What your Makefile also does not take into account is that an object file also needs to be recompiled when any of the header files it includes are touched. This kind of dependency handling is easy to do with GCC, but beyond the scope of this answer. Let me point to the Makefile tutorial at OSDev.org (which was mostly written by me) for a step-by-step introduction on how to get a Makefile "right".

Answer 2

ddd debug needs to be on a line by itself to execute as a separate command, and you need to add the missing -o switch:
debug:
g++ --std=c++11 -g -o debug main.cpp puzzle.cpp fuse.cpp
ddd debug
However, this will not execute if debug already exists; make tries to optimize and it will not run a recipe if the target already exists, or is newer than the listed dependencies (which are none).
Instead, break this rule up into two pieces. The binary (with dependencies listed), and the run command (which should be marked as a phony target). The phony target will make sure that the recipe still runs even if there is a file with the same name as the recipe's output name (run-debug in this example).
debug: main.cpp puzzle.cpp fuse.cpp
g++ --std=c++11 -g -o debug main.cpp puzzle.cpp fuse.cpp
run-debug: debug
ddd debug
.PHONY: run-debug
This way, make run-debug will always invoke the debugger (if compilation succeeded), but compilation will not be performed if the debug binary is newer than your source files.
I'm not super-familiar with ddd, but some debuggers will look up the binary in a similar way to shells, so you may need to modify the ddd line to be:
ddd ./debug
Don't forget to patch up your clean rule to (1) delete debug and (2) be phony:
clean:
-rm -f *.o main debug
.PHONY: clean run-debug