CMake es una herramienta para definir y administrar compilaciones de código, principalmente para C ++.
CMake es una herramienta multiplataforma; la idea es tener una definición única de cómo se construye el proyecto, lo que se traduce en definiciones de compilación específicas para cualquier plataforma compatible.
Esto se logra combinando con diferentes sistemas de construcción específicos de la plataforma; CMake es un paso intermedio, que genera entradas de compilación para diferentes plataformas específicas. En Linux, CMake genera Makefiles; En Windows, puede generar proyectos de Visual Studio, y así sucesivamente.
El comportamiento de la compilación se define en los archivos CMakeLists.txt
, uno en cada directorio del código fuente. El archivo CMakeLists
cada directorio define lo que debe hacer el sistema de construcción en ese directorio específico. También define qué subdirectorios CMake debe manejar también.
Las acciones típicas incluyen:
Los archivos finales de CMakeLists
pueden ser muy claros y directos, ya que cada uno tiene un alcance muy limitado. Cada uno solo maneja la mayor parte de la construcción como está presente en el directorio actual.
Para obtener recursos oficiales en CMake, consulte la documentación y el tutorial de CMake.
Versión | Fecha de lanzamiento |
---|---|
3.9 | 2017-07-18 |
3.8 | 2017-04-10 |
3.7 | 2016-11-11 |
3.6 | 2016-07-07 |
3.5 | 2016-03-08 |
3.4 | 2015-11-12 |
3.3 | 2015-07-23 |
3.2 | 2015-03-10 |
3.1 | 2014-12-17 |
3.0 | 2014-06-10 |
2.8.12.1 | 2013-11-08 |
2.8.12 | 2013-10-11 |
2.8.11 | 2013-05-16 |
2.8.10.2 | 2012-11-27 |
2.8.10.1 | 2012-11-07 |
2.8.10 | 2012-10-31 |
2.8.9 | 2012-08-09 |
2.8.8 | 2012-04-18 |
2.8.7 | 2011-12-30 |
2.8.6 | 2011-12-30 |
2.8.5 | 2011-07-08 |
2.8.4 | 2011-02-16 |
2.8.3 | 2010-11-03 |
2.8.2 | 2010-06-28 |
2.8.1 | 2010-03-17 |
2.8 | 2009-11-13 |
2.6 | 2008-05-05 |
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.
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!
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).
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)
cmake_minimum_required(VERSION 2.4)
establece una versión mínima de CMake requerida para evaluar el script actual.
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 ++.
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
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:
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.