Si solo tienes un archivo main.cpp, no necesitas nada más que un comando de terminal como g++ main.cpp -o programa. Pero en el mundo real, los proyectos crecen: tendrás docenas de archivos, librerías externas y, lo más importante, querrás que tu código compile tanto en Windows (con MSVC) como en Linux (con GCC o Clang) sin tener que reescribir los comandos de compilación a mano.
Aquí es donde entra CMake. No es un compilador ni un sistema de construcción (como Make o Ninja) por sí mismo; es un generador de sistemas de construcción. Su trabajo es leer un archivo llamado CMakeLists.txt y crear los archivos de configuración específicos para el sistema que estés usando (Makefiles en Unix o soluciones de Visual Studio en Windows). Esto garantiza la portabilidad del proyecto.
Debes usar CMake en cuanto tu proyecto deje de ser un script de un solo archivo y empiece a dividirse en módulos o necesite dependencias. Si intentas gestionar un proyecto complejo manualmente, lo primero que romperás será la gestión de dependencias entre objetos, resultando en errores de “referencia no definida” durante el linkeo. Si configuras mal las dependencias, el compilador no sabrá que el main.cpp necesita la implementación que reside en otro archivo .cpp, aunque hayas incluido el .hpp correctamente.
Para usarlo, el flujo estándar es siempre crear una carpeta de construcción separada para no ensuciar tus archivos fuente con archivos temporales del compilador. El proceso es:
1. mkdir build && cd build
2. cmake .. (esto configura el proyecto y genera los archivos de construcción).
3. cmake --build . (esto lanza el compilador real; es más portable que usar make).
Para entenderlo, veamos un proyecto que separa la lógica de una calculadora en una librería propia.
/*
Estructura del proyecto:
├── CMakeLists.txt
├── Calculadora.hpp
├── Calculadora.cpp
└── main.cpp
*/
// --- CMakeLists.txt ---
cmake_minimum_required(VERSION 3.20)
project(ProyectoCalculadora VERSION 1.0 LANGUAGES CXX)
# Definimos que usaremos el estándar C++20
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Creamos una librería estática con la lógica de la calculadora
add_library(utilidades Calculadora.cpp)
# Creamos el ejecutable principal
add_executable(app_calculadora main.cpp)
# Conectamos el ejecutable con nuestra librería
# 'PRIVATE' indica que 'app_calculadora' necesita 'utilidades' para compilar
target_link_libraries(app_calculadora PRIVATE utilidades)
// --- Calculadora.hpp ---
#ifndef CALCULADORA_HPP
#define CALCULADORA_HPP
class Calculadora {
public:
// Definimos la interfaz de nuestra lógica
int sumar(int a, int b);
};
#endif
// --- Calculadora.cpp ---
#include "Calculadora.hpp"
int Calculadora::sumar(int a, int b) {
return a + b;
}
// --- main.cpp ---
#include <iostream>
#include "Calculadora.hpp"
int main() {
Calculadora calc;
int resultado = calc.sumar(10, 32);
std::cout << "El resultado de la suma es: " << resultado << std::endl;
return 0;
}
Análisis del flujo de construcción
En el archivo CMakeLists.txt, lo primero que hacemos es establecer el entorno con cmake_minimum_required. Esto es vital para evitar que alguien con una versión obsoleta de CMake intente compilar un proyecto que usa características modernas.
Cuando ejecutamos add_library(utilidades Calculadora.cpp), le decimos a CMake que compile Calculadora.cpp de forma independiente para crear un archivo de objeto o una librería (un .lib en Windows o un .a en Linux). Esto es lo que permite la compilación incremental: si solo cambias main.cpp, el compilador no tiene que volver a procesar Calculadora.cpp, ahorrando tiempo en proyectos grandes.
El comando add_executable(app_calculadora main.cpp) define el objetivo (target) final, que es el archivo binario que el usuario ejecutará. Sin embargo, main.cpp por sí solo no sabe cómo funciona el método sumar. Por eso, target_link_libraries(app_calculadora PRIVATE utilidades) es la línea más importante: le indica al linker (enlazador) que debe buscar la implementación de los símbolos de Calculadora dentro de la librería utilidades que creamos antes.
Si cambias el modo de compilación mediante la variable CMAKE_BUILD_TYPE (por ejemplo, a Debug o Release), CMake pasará banderas distintas al compilador. En Debug, se incluirán símbolos de depuración para que puedas usar un debugger; en Release, se aplicarán optimizaciones de alto nivel (como -O3) que transforman el código para que sea lo más rápido posible.
El error frecuente
Un error de principiante muy común es intentar configurar el proyecto directamente en la carpeta raíz del código fuente en lugar de usar una carpeta build. Esto se conoce como “in-source build”.
Si ejecutas cmake . en tu carpeta principal, CMake generará una maraña de archivos CMakeCache.txt, CMakeFiles/ y archivos de compilación mezclados con tus archivos .cpp y .hpp. Si luego intentas cambiar de configuración o borrar los archivos generados para empezar de cero, es muy probable que borres algo importante por error o que el sistema se quede en un estado inconsistente que solo se arregla borrando todo manualmente.
Siempre utiliza un directorio build separado. Si algo sale mal, simplemente borras la carpeta build y tu código fuente permanece intacto y limpio.
N° 7