cmake Tutorial
Iniziare con cmake

Osservazioni

Versioni

Installazione di CMake

Vai alla pagina di download di CMake e ottieni un file binario per il tuo sistema operativo, ad esempio Windows, Linux o Mac OS X. In Windows fai doppio clic sul file binario da installare. Su Linux esegui il binario da un terminale.

Su Linux, puoi anche installare i pacchetti dal gestore di pacchetti della distribuzione. Su Ubuntu 16.04 puoi installare la riga di comando e l'applicazione grafica con:

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

Su FreeBSD puoi installare la riga di comando e l'applicazione grafica basata su Qt con:

pkg install cmake
pkg install cmake-gui

Su Mac OSX, se si utilizza uno dei gestori di pacchetti disponibili per installare il software, il più notevole dei quali è MacPorts ( MacPorts ) e Homebrew ( Homebrew ), è possibile anche installare CMake tramite uno di essi. Ad esempio, in caso di MacPorts, digitare quanto segue

sudo port install cmake  

installerà CMake, mentre nel caso utilizzi il gestore di pacchetti Homebrew dovrai digitare

brew install cmake

Dopo aver installato CMake, puoi verificare facilmente procedendo come segue

cmake --version

Dovresti vedere qualcosa di simile al seguente

cmake version 3.5.1

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

Passaggio tra tipi di build, ad es. Debug e release

CMake conosce diversi tipi di build, che di solito influenzano i parametri predefiniti del compilatore e del linker (come le informazioni di debug in fase di creazione) o percorsi di codice alternativi.

Per impostazione predefinita, CMake è in grado di gestire i seguenti tipi di build:

• Debug : solitamente una classica build di debug che include informazioni di debug, nessuna ottimizzazione, ecc.
• Versione : la tipica versione di rilascio senza informazioni di debug e ottimizzazione completa.
• RelWithDebInfo:: uguale a Release , ma con informazioni di debug.
• MinSizeRel : una versione di rilascio speciale ottimizzata per le dimensioni.

Le modalità di gestione delle configurazioni dipendono dal generatore che viene utilizzato.

Alcuni generatori (come Visual Studio) supportano più configurazioni. CMake genererà tutte le configurazioni contemporaneamente e potrai selezionare dall'IDE o usare --config CONFIG (con cmake --build ) quale configurazione vuoi costruire. Per questi generatori, CMake farà del suo meglio per generare una struttura di directory di build in modo che i file di configurazioni diverse non si sovrappongano.

I generatori che supportano solo una singola configurazione (come Unix Makefile) funzionano diversamente. Qui la configurazione attualmente attiva è determinata dal valore della variabile CMake CMAKE_BUILD_TYPE .

Ad esempio, per scegliere un tipo di build diverso, è possibile eseguire i seguenti comandi da riga di comando:

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

Uno script CMake dovrebbe evitare di impostare lo stesso CMAKE_BUILD_TYPE , poiché generalmente è considerata responsabilità dell'utente farlo.

Per i generatori a configurazione singola, il passaggio alla configurazione richiede la riesecuzione di CMake. È probabile che una build successiva sovrascriva i file oggetto prodotti dalla configurazione precedente.

Semplice progetto "Hello World"

Dato un file di origine C ++ main.cpp definisce una funzione main() , un file CMakeLists.txt accompagnamento (con il seguente contenuto) istruirà CMake a generare le istruzioni di compilazione appropriate per il sistema corrente e il compilatore C ++ predefinito.

main.cpp ( C ++ Hello World Example )

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

Guardalo dal vivo su Coliru

1. cmake_minimum_required(VERSION 2.4) imposta una versione CMake minima necessaria per valutare lo script corrente.

2. project(hello_world) avvia un nuovo progetto CMake. Ciò attiverà molta logica interna di CMake, in particolare il rilevamento del compilatore C e C ++ predefinito.

3. Con add_executable(app main.cpp) viene creata app destinazione build che invoca il compilatore configurato con alcuni flag predefiniti per l'impostazione corrente per compilare app eseguibile dal file di origine specificato main.cpp .

Riga di comando (In-Source-Build, not recommended)

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

cmake . esegue il rilevamento del compilatore, valuta il CMakeLists.txt nel dato . directory e genera l'ambiente di compilazione nella directory di lavoro corrente.

Il cmake --build . comando è un'astrazione per la chiamata build / make necessaria.

Riga di comando (Out-of-Source, raccomandato)

Per mantenere il tuo codice sorgente pulito da eventuali artefatti di costruzione, dovresti creare build "fuori dall'origine".

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

Oppure CMake può anche astrarre i comandi di base della tua piattaforma shell dall'esempio sopra riportato:

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

"Hello World" con più file sorgente

Per prima cosa possiamo specificare le directory dei file di intestazione da include_directories() , quindi dobbiamo specificare i corrispondenti file di origine dell'eseguibile di destinazione da add_executable() , e accertarci che esista esattamente una funzione main() nei file di origine.

Di seguito è riportato un semplice esempio, tutti i file vengono presupposti inseriti nella directory 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

Possiamo seguire la stessa procedura nell'esempio precedente per costruire il nostro progetto. Quindi l' app esecuzione verrà stampata

>./app
Hello World!

"Hello World" come libreria

Questo esempio mostra come distribuire il programma "Hello World" come libreria e come collegarlo ad altri target.

Supponiamo di avere lo stesso set di file sorgente / header come nell'esempio http://www.Scriptutorial.com/cmake/example/22391/-hello-world--with-multiple-source-files . Invece di costruire da più file sorgente, possiamo prima distribuire foo.cpp come libreria usando add_library() e successivamente collegandolo con il programma principale con target_link_libraries() .

Modifichiamo CMakeLists.txt in

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)

e seguendo gli stessi passi, otterremo lo stesso risultato.