Introduction to CMake: Essential for Building Modern C++ Projects

Hello everyone! As a C++ programmer, I understand the importance of build tools. Today, I want to share with you CMake – a powerful cross-platform build tool. Don’t be intimidated by the term “build tool”; follow me step by step, and you’ll find that CMake is actually quite easy to understand and is particularly helpful for C++ project development.

Why Do We Need CMake?

Do you remember when I first started learning C++, I only needed a single source file and could compile it directly with g++? But as projects grow larger and the number of source files increases, manual compilation becomes particularly cumbersome. Not to mention the various configuration issues when compiling on different operating systems.

This is where CMake comes into play. It acts like a smart assistant, helping us:

Manage all source files in the project
Automatically handle dependencies
Generate build files suitable for different platforms

Your First CMake Project

Let’s start with the simplest example. Suppose we have a small project like this:

// main.cpp
#include <iostream>

int main() {
    std::cout << "Hello, CMake!" << std::endl;
    return 0;
}

To build this project with CMake, we need to create a file called CMakeLists.txt:

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(HelloCMake)
add_executable(hello main.cpp)

It’s that simple! Let me explain these three lines of code:

cmake_minimum_required: Specifies the minimum required version of CMake
project: Sets the project name
add_executable: Tells CMake to create an executable file

How to Use CMake to Build a Project

Next are the build steps:

Create a build directory (I usually call it build):

mkdir build
cd build

Generate build files:

cmake ..

Start building:

cmake --build .

Tip: I recommend always using an external build (i.e., building in a separate build directory) to keep the source code directory clean.

Projects with Multiple Source Files

In real projects, we often have multiple source files. Let’s look at an example:

// math.h
#pragma once

int add(int a, int b);
int subtract(int a, int b);

// math.cpp
#include "math.h"

int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

// main.cpp
#include <iostream>
#include "math.h"

int main() {
    std::cout << "10 + 5 = " << add(10, 5) << std::endl;
    return 0;
}

The corresponding CMakeLists.txt:

cmake_minimum_required(VERSION 3.10)
project(MathProject)

# Add all source files to a variable
set(SOURCES
    main.cpp
    math.cpp
)

add_executable(mathapp ${SOURCES})

Note: Header files (.h) do not need to be listed in CMakeLists.txt; CMake will automatically handle the include relationships.

Adding Compilation Options

In actual development, we often need to set some compilation options. For example:

# Enable C++11 standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Add compilation options
if(MSVC)
    target_compile_options(mathapp PRIVATE /W4)
else()
    target_compile_options(mathapp PRIVATE -Wall -Wextra)
endif()

Tip: Here, conditional statements are used to handle different compiler warning options; MSVC is the compiler for Visual Studio.

Practical Tasks

Try to complete these tasks on your own:

Create a small project with 3 source files
Modify CMakeLists.txt to add the -O2 optimization option
Try building your project on different platforms

Conclusion

Today we learned the basics of using CMake:

Creating a basic CMakeLists.txt file
Managing multiple source files
Setting compilation options
The basic steps to build a project

Although this is just the tip of the iceberg with CMake, it already meets the needs of most small projects. Remember, practice makes perfect; the more you try, the better you’ll master it. Next time, we will explore how to use CMake to manage third-party libraries, so stay tuned!

If you encounter problems during practice, don’t worry; it’s completely normal. Feel free to discuss and share in the comments!