I may have wrote this post, but I'm just being lazy... Read on.
I've made other Boost videos, and other codeblocks videos, and I've always assumed that the user at the other end was well aware of how to compile & build code.
However, it seems there are lots of users whom are not aware of how you actual create a program from source code, at least not with C++.
So I'm going to show you the absolutely most wrong basic way of creating and using a makefile to perform a build...
The first step of C++ program creation, is that trivial matter of creating the source code, easy right?... Yep, so lets skip that step, and go to when its once and we want to pass the code through a compiler, the compiler turns the source not into a program, but into an intermediary format called an object file or object code.
The compiler then leaves the process and another program takes over, this second program is known as the Linker, and it takes the object code and links it with all the system calls and other libraries you are wishing to use.
There are other steps involved in the process of building a program, however, compiling & linking are the two main steps; when I began programming you were made very much aware of this by the compiler and linker generally being such large complex programs and the libraries being so big you had to physically change floppy disk between the different steps of the process.
This process was also taught to me in school & later college, it was common practice to understand a compiled program was actually compiled then linked.
Unfortunately, this knowledge seems to have fallen in to the way side, it is of course more important to learn how to program than be bogged down in minutia, however, once you have learned I strongly believe you should expand your knowledge and really have a holistic knowledge of the craft of programming.
So, back to our program, the make file, what might they look like? Well they are simply text files, which contain commands very similar to bash script... We call this make file script by passing it to the "make" program, you can get make for Linux, mac or alongside MinGW for windows.
Lets start writing a make file for any basic C++ program, which links the Boost libraries we've built somewhere on disk, and which looks like this:
#include <iostream>
#include <string>
#include <boost/filesystem.hpp>
int main (int p_argc, char** p_argv)
{
if ( p_argc > 1 )
{
std::cout << "File or Folder ";
std::string l_pathString(p_argv[1]);
boost::filesystem::path l_path(l_pathString);
if ( boost::filesystem::exists(l_path) )
{
std::cout << "Exists!";
}
else
{
std::cout << "Not Found";
}
std::cout << std::endl;
}
}
Save this as "main.cpp" and then define a variable called "FILES" into which we place this filename.
FILES=main.cpp
We want to start our make file with a variable which contains the compiler we wish to use, for Linux on my test machine I'll use "g++".
CC=g++
So now we have a value called "CC" which is a string of characters with the value "g++". The dollar sign indicates that "CC" is a variable within the script, which we might want to use later, I use these kind of variables throughout makefiles so I can place at the top any paths or references I like, or I can alter them when I move the makefile from Linux to say Windows, without needing to change hundreds of places throughout the script, I can change just one location.
I find this working with strings is 95% of what working with makefiles is about, next in the file we then define the strings for where to find both the boost headers and the binary libraries are...
BOOST_INC=/home/xelous/boost
BOOST_LIB=$(BOOST_INC)/stage/lib
Notice, I create the root folder for boost as one variable, and then in the next line I use that variable to extend into the "stage/lib" folder, so I never duplicate the root folder for the boost libraries.
We can now define at least our build command, slightly different the command is a verb, in this case "build", which is the command we will use here, but which is also the default. If you save this makefile as "makefile" in a folder, then navigate your console to that same folder and type "make", the make program will look for "makefile" by default, find it and build the "build" verb by default!
build:
$(CC) -I$(BOOST_INC) -L$(BOOST_LIB)
So, what is this command doing? Well it is saying to use the compiler, with the Include folder for boost and look for libraries in the boost library folder we've set.
The "-I" and "-L" parameters are the same parameters one would use on the command line for "g++". This command therefore equates to "g++ -I/home/xelous/boost -L/home/xelous/boost/stage/lib", but I think you will agree it is somewhat easier to manage.
We also need to tell the program to link against some libraries, and that we want them linked statically in this case. So our next variable will be called "CFLAGS1" to pass the Compiler flags to the command. Back at the top of our make file I therefore add....
CFLAGS1=-fpermissive -Wl,-Bstatic
This file tells the compiler to be permissive of some common errors and treat them as warnings. You can use whatever parameters you wish for your compile, the flags available and their meaning are quite varied, however you will need to use a second set to within the build command, so lets define that now....
CFLAGS2=-static-libstdc++ -std=c++14
The second tells the compiler and linker to link against the static versions of the libraries we select later, you will need to look at the boost invocation pages in order to go back over our previous posts and build boost static and take advantage of this option.
I'm not going to explain static linking here, nor any of the other switches, available.
Now we're linking the C++ standard library, and boost, statically we need another variable with the list of libraries to link, on the command line to g++ this is with the "-l" (lowercase L), except with we are going to make the program threaded, so we can set up a new makefile script variable called "LIBS", into which we set the libraries, like so.
LIBS=-pthread -lboost_signals -lboost_system -lboost_filesystem
We now have the compiler, the folders, the libraries, the flags... What about the target file for the build?... Well I want it to be an executable called "fredrick".
TARGET=-o fredrick
Now we need to put this all together into a command, just running the script with the variables does nothing, we need to define a verb... Lets call this "build" a verb in the makefile has to have a colon following it...
build:
And we can tell make what to perform for a build:
build:
$(CC) -I$(BOOST_INC) -L$(BOOST_LIB) $(CFLAGS1) $(FILES) $(CFLAGS2) $(LIBS) $(TARGET)
We might also want to clean the project, so we'd want to delete the target file maybe, by adding another verb:
clean:
rm $(TARGET)
We can then perform the call "make build" or "make clean" in the folder with this makefile and perform our build.
A bit rough and ready, but it works to get you up and running.
