Getting Started with CMake Build Tool

Hello everyone, today I want to share with you a very practical tool – CMake. As a programmer, I understand the importance of managing and building code when developing large projects. CMake is like a project management assistant that helps us handle complex issues such as code compilation and dependencies. Don’t be intimidated by it, follow me to learn, and you will find that CMake is actually very friendly!

What is CMake?

CMake is a cross-platform build tool that can generate various build systems (such as Makefile, Visual Studio projects, etc.) based on simple configuration files. For example, if we compare our code to the materials for building a house, CMake is like the architect’s blueprint, telling the workers (the compiler) how to assemble these materials into a house.

Your First CMake Project

Let’s start with the simplest example. Suppose we have a C++ program that prints “Hello World”:

cpp copy

// main.cpp
#include <iostream>

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

To build this program, we need to create a CMakeLists.txt file:

cmake copy

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(HelloCMake)

add_executable(hello_cmake main.cpp)

Tip: CMakeLists.txt is the configuration file for CMake that tells CMake how to build our project.

Understanding Basic CMake Commands

Let me explain each line in the above CMakeLists.txt:

1. cmake_minimum_required: Sets the minimum required version of CMake
2. project: Sets the project name
3. add_executable: Tells CMake to create an executable file

Build Process

To build the project, we need to execute the following steps:

bash copy

# Create build directory
mkdir build
cd build

# Generate build system
cmake ..

# Execute build
cmake --build .

Note: It is recommended to build in a separate build directory to keep the source code directory clean.

Adding Library Files

In actual projects, we often need to create and use library files. Let’s see how to do it:

cmake copy

# Create static library
add_library(mylib STATIC
    src/mylib.cpp
)

# Link library file
target_link_libraries(hello_cmake
    PRIVATE mylib
)

Tip: STATIC means creating a static library, and SHARED can be used to create a dynamic library.

Managing Multiple Source Files

As the project grows, we need to manage multiple source files:

cmake copy

# Add all source files
file(GLOB_RECURSE SOURCES 
    "src/*.cpp"
    "src/*.h"
)

add_executable(hello_cmake ${SOURCES})

Note: Although GLOB_RECURSE is convenient, it’s better to explicitly list source files in large projects to manage dependencies more easily.

Conditional Compilation

CMake supports conditional statements, allowing conditional compilation based on different platforms or configurations:

cmake copy

if(WIN32)
    add_definitions(-DWINDOWS_PLATFORM)
elseif(UNIX)
    add_definitions(-DUNIX_PLATFORM)
endif()

Practical Exercise

Try creating a project with the following structure:

• A main program
• A static library
• Using conditional compilation to output different information based on the operating system

Summary

Today we learned the basics of CMake, including:

• The basic structure of a CMakeLists.txt file
• How to create executable files and library files
• Methods for managing multiple source files
• Using conditional compilation

Remember, CMake is like the “architectural blueprint” of the project; mastering it can make our project builds more professional and efficient. I encourage you to practice the knowledge learned today, starting with simple projects and gradually improving.

Next time, we will delve into more advanced features of CMake. Keep it up!

(End of article)