Looking for cmake Answers? Try Ask4KnowledgeBase
Looking for cmake Keywords? Try Ask4Keywords

cmakeEmpezando con cmake


Observaciones

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:

  • Cree una biblioteca o un ejecutable a partir de algunos de los archivos de origen en este directorio.
  • Agregue una ruta de archivo a la ruta de inclusión utilizada durante la compilación.
  • Defina las variables que el sistema de construcción utilizará en este directorio y en sus subdirectorios.
  • Generar un archivo, basado en la configuración de construcción específica.
  • Localice una biblioteca que se encuentra en algún lugar del árbol de origen.

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.

Versiones

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

"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.

"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!
 

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).
 

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 
 

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.