cmake Tutorial
Empezando con cmake

Observaciones

Versiones

Instalación CMake

Diríjase a la página de descargas de CMake y obtenga un binario para su sistema operativo, por ejemplo, Windows, Linux o Mac OS X. En Windows, haga doble clic en el binario para instalar. En Linux ejecuta el binario desde un terminal.

En Linux, también puede instalar los paquetes desde el administrador de paquetes de la distribución. En Ubuntu 16.04 puede instalar la línea de comandos y la aplicación gráfica con:

sudo apt-get install cmake
sudo apt-get install cmake-gui

En FreeBSD puede instalar la línea de comandos y la aplicación gráfica basada en Qt con:

pkg install cmake
pkg install cmake-gui

En Mac OSX, si utiliza uno de los administradores de paquetes disponibles para instalar su software, el más notable es MacPorts ( MacPorts ) y Homebrew ( Homebrew ), también puede instalar CMake a través de uno de ellos. Por ejemplo, en el caso de MacPorts, escriba lo siguiente

sudo port install cmake  

instalará CMake, mientras que en el caso de que utilice el gestor de paquetes Homebrew, escribirá

brew install cmake

Una vez que haya instalado CMake, puede verificar fácilmente haciendo lo siguiente

cmake --version

Deberías ver algo similar a lo siguiente

cmake version 3.5.1

CMake suite maintained and supported by Kitware (kitware.com/cmake).

Cambio entre tipos de compilación, por ejemplo, depuración y lanzamiento

CMake conoce varios tipos de compilación, que generalmente influyen en los parámetros predeterminados del compilador y el vinculador (como la información de depuración que se está creando) o rutas de código alternativas.

De forma predeterminada, CMake puede manejar los siguientes tipos de compilación:

• Depuración : por lo general, una compilación de depuración clásica que incluye información de depuración, no optimización, etc.
• Lanzamiento : su compilación de lanzamiento típica sin información de depuración y optimización completa.
• RelWithDebInfo:: igual que la versión , pero con información de depuración.
• MinSizeRel : una versión de lanzamiento especial optimizada para el tamaño.

La forma en que se manejan las configuraciones depende del generador que se esté utilizando.

Algunos generadores (como Visual Studio) admiten configuraciones múltiples. CMake generará todas las configuraciones a la vez y puede seleccionar desde el IDE o mediante --config CONFIG (con cmake --build ) la configuración que desea compilar. Para estos generadores, CMake hará todo lo posible para generar una estructura de directorios de compilación de tal manera que los archivos de diferentes configuraciones no se pisen entre sí.

Los generadores que solo admiten una configuración única (como Unix Makefiles) funcionan de manera diferente. Aquí la configuración actualmente activa está determinada por el valor de la variable CMake CMAKE_BUILD_TYPE .

Por ejemplo, para elegir un tipo de construcción diferente, uno podría emitir los siguientes comandos de la línea de comandos:

cmake -DCMAKE_BUILD_TYPE=Debug path/to/source
cmake -DCMAKE_BUILD_TYPE=Release path/to/source

Un script de CMake debe evitar establecer el CMAKE_BUILD_TYPE , ya que generalmente se considera la responsabilidad de los usuarios de hacerlo.

Para los generadores de una sola configuración, cambiar la configuración requiere volver a ejecutar CMake. Es probable que una compilación posterior sobrescriba los archivos de objetos producidos por la configuración anterior.

Proyecto simple "Hola Mundo"

Dado un archivo fuente C ++ main.cpp define una función main() , un archivo CMakeLists.txt adjunto (con el siguiente contenido) le indicará a CMake que genere las instrucciones de compilación adecuadas para el sistema actual y el compilador C ++ predeterminado.

main.cpp ( Ejemplo de C ++ Hello World )

#include <iostream>

int main()
{
    std::cout << "Hello World!\n";
    return 0;
}

CMakeLists.txt

cmake_minimum_required(VERSION 2.4)

project(hello_world)

add_executable(app main.cpp)

Véalo en vivo en Coliru

1. cmake_minimum_required(VERSION 2.4) establece una versión mínima de CMake requerida para evaluar el script actual.

2. project(hello_world) inicia un nuevo proyecto CMake. Esto activará una gran cantidad de lógica interna de CMake, especialmente la detección del compilador predeterminado de C y C ++.

3. Con add_executable(app main.cpp) crea una app destino de compilación, que invocará al compilador configurado con algunos indicadores predeterminados para la configuración actual para compilar una app ejecutable desde el archivo de origen main.cpp .

Línea de comando (In-Source-Build, no recomendado)

> cmake .
...
> cmake --build .

cmake . hace la detección del compilador, evalúa el CMakeLists.txt en el dado . Directorio y genera el entorno de compilación en el directorio de trabajo actual.

El cmake --build . El comando es una abstracción para la compilación / creación necesaria.

Línea de comando (fuera de la fuente, recomendado)

Para mantener su código fuente limpio de cualquier artefacto de compilación, debe hacer compilaciones "fuera de la fuente".

> mkdir build
> cd build
> cmake ..
> cmake --build .

O CMake también puede abstraer los comandos básicos del shell de su plataforma del ejemplo anterior:

> cmake -E make_directory build
> cmake -E chdir build cmake .. 
> cmake --build build 

"Hello World" con múltiples archivos fuente

Primero podemos especificar los directorios de los archivos de encabezado por include_directories() , luego necesitamos especificar los archivos de origen correspondientes del ejecutable de destino por add_executable() , y asegurarnos de que exista una función main() en los archivos de origen.

A continuación se muestra un ejemplo simple, se supone que todos los archivos se encuentran en el directorio PROJECT_SOURCE_DIR .

main.cpp

#include "foo.h"

int main()
{
    foo();
    return 0;
}

foo.h

void foo();

foo.cpp

#include <iostream>
#include "foo.h"

void foo()
{
    std::cout << "Hello World!\n";
}

CMakeLists.txt

cmake_minimum_required(VERSION 2.4)

project(hello_world)

include_directories(${PROJECT_SOURCE_DIR})
add_executable(app main.cpp foo.cpp)  # be sure there's exactly one main() function in the source files

Podemos seguir el mismo procedimiento en el ejemplo anterior para construir nuestro proyecto. Luego se ejecutará la app ejecutando

>./app
Hello World!

"Hola mundo" como biblioteca

Este ejemplo muestra cómo implementar el programa "Hello World" como una biblioteca y cómo vincularlo con otros destinos.

Supongamos que tenemos el mismo conjunto de archivos de origen / encabezado que en el ejemplo http://www.riptutorial.com/cmake/example/22391/-hello-world--with-multiple-source-files . En lugar de foo.cpp desde múltiples archivos de origen, primero podemos implementar foo.cpp como una biblioteca utilizando add_library() y luego vincularlo con el programa principal con target_link_libraries() .

Modificamos CMakeLists.txt para

cmake_minimum_required(VERSION 2.4)

project(hello_world)

include_directories(${PROJECT_SOURCE_DIR})
add_library(applib foo.cpp)
add_executable(app main.cpp)
target_link_libraries(app applib)

Y siguiendo los mismos pasos, obtendremos el mismo resultado.