CMake
![cmake logo](https://upload.wikimedia.org/wikipedia/commons/8/8f/Breezeicons-apps-48-cmake.svg)
# Cmake

# Multiple Source Files and Headers

Building with Cmake was easy for a simple hello world program. What about a program with multiple files?

No sweat.

## Structure
We will create a directory called **FooBar**, and we will create 2 more directories inside of it called **includes** and **sources**.

In the terminal:

```
mkdir ./FooBar/sources ./FooBar/includes
cd ./FooBar
```
## Code Some Headers
Here we'll make some very simple header files inside the includes folder. Each will have only one function prototype and nothing else.

In terminal:
```
echo "void foo();" > ./includes/foo.h
echo "void bar();" > ./includes/bar.h
```
Normally we would also put some header guards in those files but this is just a speedy demo and it works.

## Code Some Sources
Here we need 3 cpp files. We will put them in the sources folder.

We need **main.cpp**, **foo.cpp** and **bar.cpp**.

Using a text editor, we create and edit those 3 files so they look like this:
```
//main.cpp
#include < iostream >
#include "foo.h"
#include "bar.h"

int main(){
    foo();
    bar();
    return 0;
}
```
```
//foo.cpp
#include < iostream >

void foo(){
    std::cout << "foo called" << std::endl;
}
```
```
//bar.cpp
#include < iostream >

void bar(){
    std::cout << "bar called" << std::endl;
}
```

## CMakeLists.txt
We also need to create a **CMakeLists.txt** file in the FooBar folder like this:

```
cmake_minimum_required(VERSION 3.0)

project(FooBar VERSION 0.0.1 LANGUAGES CXX)

set(my_includes 
    "./includes/foo.h" 
    "./includes/bar.h")

include_directories("./includes")

set(my_sources 
    "./sources/main.cpp" 
    "./sources/foo.cpp" 
    "./sources/bar.cpp")

add_executable(foobar 
               ${my_sources} 
               ${my_includes})
```
Here we see a couple new functions we didnt see in the previous tutorial:
- set: create a variable and set it to a value.
- include_directories: declare where to find the headers

So here we create two variables that we later link in the add_executable function, namely **my_sources** and **my_includes**.

## Run Cmake and Execute
cd to FooBar folder, then:
```
cmake -S . -B builds -G "Unix Makefiles"
```

Build the executable.

```
cmake --build ./builds
```

Execute.

```
./builds/foobar
```

It should print:

```
foo called
bar called
```

## Final Directory And File Structure

Just for show let's get an overview of the project structure.

In terminal type:
```
tree
```

If tree tool is installed you might get something similar

```
.
├── CMakeLists.txt
├── builds
│   ├── CMakeCache.txt
│   ├── CMakeFiles
│   │   ├── 3.18.1
│   │   │   ├── CMakeCXXCompiler.cmake
│   │   │   ├── CMakeDetermineCompilerABI_CXX.bin
│   │   │   ├── CMakeSystem.cmake
│   │   │   └── CompilerIdCXX
│   │   │       ├── CMakeCXXCompilerId.cpp
│   │   │       ├── a.out
│   │   │       └── tmp
│   │   ├── CMakeDirectoryInformation.cmake
│   │   ├── CMakeOutput.log
│   │   ├── CMakeTmp
│   │   ├── Makefile.cmake
│   │   ├── Makefile2
│   │   ├── TargetDirectories.txt
│   │   ├── cmake.check_cache
│   │   ├── foobar.dir
│   │   │   ├── CXX.includecache
│   │   │   ├── DependInfo.cmake
│   │   │   ├── build.make
│   │   │   ├── cmake_clean.cmake
│   │   │   ├── depend.internal
│   │   │   ├── depend.make
│   │   │   ├── flags.make
│   │   │   ├── link.txt
│   │   │   ├── progress.make
│   │   │   └── src
│   │   │       ├── bar.cpp.o
│   │   │       ├── foo.cpp.o
│   │   │       └── main.cpp.o
│   │   └── progress.marks
│   ├── Makefile
│   ├── cmake_install.cmake
│   └── foobar
├── includes
│   ├── bar.h
│   └── foo.h
└── sources
    ├── bar.cpp
    ├── foo.cpp
    └── main.cpp

10 directories, 34 files
```
As we can all see, there is quite a lot of visual pollution inside the builds folder. It is highly recommended, if the code has a git, to put the builds folder in the **.gitignore** file.

## File Glob (optional trick)

We could also use the file function to set **my_sources** and **my_includes** in the **CMakeLists.txt**.

We could replace 

```
set(my_sources 
    "./sources/main.cpp" 
    "./sources/foo.cpp" 
    "./sources/bar.cpp")
```

by

```
file(GLOB my_sources "./sources/*.cpp")
```

and replace

```
set(my_includes 
    "./includes/foo.h" 
    "./includes/bar.h")
```

by

```
file(GLOB my_includes "./includes/*.h")
```

Thus simplifying the cmake code. It also keeps the code valid when other files are introduced and we dont need to change the cmake code. Another bonus is that it makes it easier to reuse the same cmake code in another project with only very minor modifications to do.

© Paul Caron, aka ChillPill
Cmake Tutorial - Multiple files, headers
