First attempt at makefiles - c++

Question

I am writing my first second makefile because I need to understand them before I can actually start my C++ project. Here's the files I'm trying to link:
/storage/emulated/0/cpptest/test.h
#ifndef TEST_H_DEF
#define TEST_H_DEF
class Test {
private:
int value;
public:
Test(int);
operator int();
Test operator + (Test);
};
#endif
/storage/emulated/0/cpptest/test.cpp
#include "test.h"
Test::Test(int new_value):
value(new_value) {}
Test::operator int() {
return value;
}
Test Test::operator + (Test other) {
return Test(value + int(other));
}
/storage/emulated/0/cpptest/main.cpp
#include <iostream>
#include "test.h"
int main() {
Test o1(12);
Test o2(18);
std::cout << int(o1) << '\n';
std::cout << int(o2) << '\n';
std::cout << int(o1 + o2) << std::endl;
}
And here's my attempt at a (maintainable) makefile:
CC = g++
default: test
#I'm actually using four spaces here on SO
test: main.o test.o
$(CC) -o test main.o test.o
#my issue starts here: what does main.o depends on? My guess is main.cpp only (which is really /storage/emulated...main.cpp)
main.o: main.cpp
$(CC) -o main.o /storage/emulated/0/cpptest/main.cpp
#same with test.o
test.o: test.cpp
$(CC) -o test.o /storage/emulated/0/cpptest/test.cpp
And then? Am I fine now? How do I handle the issue of test.h being updated without make knowing about it?
Also did I get the usage of .h and .cpp files right while writing my files?

Answer 1

gcc can generate dependencies for you. So rather than manually typing out what all dependencies your source files have (which will inevitably be wrong or incomplete), use the compiler:
default: test
.PHONY : default
compiler := g++
objects := main.o test.o
depends := $(objects:.o=.d)
# include the depends rules if they exist
-include $(depends)
# test depends on all the objects, compiled together
test : $(objects)
$(compiler) -o $# $^
# each object depends on its source file
# the recipe here will both compile the source file and generate its dependencies
%.o : %.cpp
$(compiler) -o $# -c $< -MP -MMD -MF $(#:.o=.d)
This will generate files for you named main.d and test.d which will contain makefile rules with the actual dependencies of main.cpp and test.cpp.
Whenever you're in doubt about the validity of your makefiles, it's always helpful to run make -pn and examine everything that's printed there. That will help make sure your dependencies are entirely the way they should be.
For example, the first time you compile, the *.d files won't exist, so the include $(depends) command will fail (silently because of -include), and this makefile creates a dependency graph that looks like:
You should read this as any node needs to have its recipes rerun if any of its children have been updated (I filled in default blue because it's a phony rule.). So main.o needs to be recompiled whenever main.cpp gets updated. Note that there is no dependency on test.h! This may seem like a mistake, but we have to recompile everything anyway, so we're not missing out. After we compile the first time, we'll have generated the *.d files and then we bring those into our include, and the new dependency graph looks like:
which is exactly what we want.

Answer 2

The dependency of test.h is for both test.cpp and main cpp:
CC = g++
default: test
test: main.o test.o
$(CC) -o test main.o test.o
main.o: main.cpp test.h
$(CC) -o main.o /storage/emulated/0/cpptest/main.cpp
test.o: test.cpp test.h
$(CC) -o test.o /storage/emulated/0/cpptest/test.cpp
The idea is that if something changes within test.h both test.o and main.o must be remade.