cmake Zelfstudie
Aan de slag met cmake

Opmerkingen

versies

CMake Installatie

Ga naar CMake downloadpagina en krijg een binair bestand voor uw besturingssysteem, bijvoorbeeld Windows, Linux of Mac OS X. Dubbelklik op Windows op het te installeren binaire bestand. Voer onder Linux het binaire bestand uit vanaf een terminal.

In Linux kunt u de pakketten ook installeren vanuit de pakketbeheerder van de distributie. Op Ubuntu 16.04 kunt u de opdrachtregel en grafische toepassing installeren met:

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

Op FreeBSD kunt u de opdrachtregel en de op Qt gebaseerde grafische applicatie installeren met:

pkg install cmake
pkg install cmake-gui

Als u op Mac OSX een van de beschikbare pakketmanagers gebruikt om uw software te installeren, met als meest opvallende MacPorts ( MacPorts ) en Homebrew ( Homebrew ), kunt u CMake ook via een van hen installeren. Typ bijvoorbeeld in het geval van MacPorts het volgende

sudo port install cmake  

installeert CMake, terwijl u typt als u de Homebrew-pakketmanager gebruikt

brew install cmake

Nadat u CMake hebt geïnstalleerd, kunt u dit eenvoudig controleren door het volgende te doen

cmake --version

Je zou iets moeten zien dat lijkt op het volgende

cmake version 3.5.1

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

Schakelen tussen buildtypen, bijvoorbeeld debug en release

CMake kent verschillende buildtypen, die meestal de standaardcompiler- en linkerparameters beïnvloeden (zoals foutopsporingsinformatie die wordt gemaakt) of alternatieve codepaden.

Standaard kan CMake de volgende buildtypen verwerken:

• Foutopsporing : meestal een klassieke foutopsporingsopbouw inclusief foutopsporingsinformatie, geen optimalisatie enz.
• Release : uw typische release-build zonder foutopsporingsinformatie en volledige optimalisatie.
• RelWithDebInfo:: hetzelfde als release , maar met foutopsporingsinformatie.
• MinSizeRel : een speciale versie die is geoptimaliseerd voor grootte.

Hoe configuraties worden verwerkt, is afhankelijk van de generator die wordt gebruikt.

Sommige generators (zoals Visual Studio) ondersteunen meerdere configuraties. CMake zal alle configuraties in één keer genereren en u kunt kiezen uit de IDE of met behulp van --config CONFIG (met cmake --build ) welke configuratie u wilt bouwen. Voor deze generatoren zal CMake zijn best doen om een build-directorystructuur te genereren zodat bestanden uit verschillende configuraties niet op elkaar stappen.

Generatoren die slechts één configuratie ondersteunen (zoals Unix Makefiles) werken anders. Hier wordt de momenteel actieve configuratie bepaald door de waarde van de CMAKE_BUILD_TYPE variabele CMAKE_BUILD_TYPE .

Als u bijvoorbeeld een ander buildtype kiest, kunt u de volgende opdrachtregelopdrachten geven:

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

Een CMake-script moet voorkomen dat de CMAKE_BUILD_TYPE zelf wordt ingesteld, omdat het algemeen wordt beschouwd als de verantwoordelijkheid van de gebruiker om dit te doen.

Voor generatoren met één configuratie vereist het schakelen van de configuratie CMake opnieuw uitvoeren. Een volgende build overschrijft waarschijnlijk objectbestanden die zijn geproduceerd door de eerdere configuratie.

Eenvoudig "Hello World" -project

Gegeven een C ++ bronbestand main.cpp die een main() functie, een begeleidend CMakeLists.txt bestand (met de volgende inhoud) instrueert CMake de juiste build instructies voor het huidige systeem genereren en standaard C ++ compiler.

main.cpp ( C ++ Hallo wereld voorbeeld )

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

Zie het live op Coliru

1. cmake_minimum_required(VERSION 2.4) stelt een minimale CMake-versie in die vereist is om het huidige script te evalueren.

2. project(hello_world) start een nieuw CMake-project. Dit zal veel interne CMake-logica activeren, met name de detectie van de standaard C- en C ++ -compiler.

3. Met add_executable(app main.cpp) een build doel app is gemaakt, die de geconfigureerde compiler met een aantal standaard vlaggen voor de huidige instelling zal roepen om een uitvoerbaar bestand te compileren app uit de gegeven bronbestand main.cpp .

Opdrachtregel (In-Source-build, niet aanbevolen)

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

cmake . doet de compiler detectie, evalueert de CMakeLists.txt in de gegeven . map en genereert de buildomgeving in de huidige werkmap.

De cmake --build . commando is een abstractie voor de benodigde build / call.

Opdrachtregel (buiten bron, aanbevolen)

Om uw broncode vrij te houden van build-artefacten, moet u "out-of-source" builds uitvoeren.

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

Of CMake kan de basisopdrachten van uw platformshell ook abstraheren uit het voorbeeld van hierboven:

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

"Hallo wereld" met meerdere bronbestanden

Eerst kunnen we de mappen van header-bestanden specificeren door include_directories() , daarna moeten we de overeenkomstige bronbestanden van het add_executable() door add_executable() , en er zeker van zijn dat er precies één main() functie in de bronbestanden is.

Hierna volgt een eenvoudig voorbeeld, alle bestanden worden verondersteld in de map PROJECT_SOURCE_DIR zijn geplaatst.

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

We kunnen dezelfde procedure volgen in het bovenstaande voorbeeld om ons project te bouwen. Vervolgens wordt de uitvoerende app afgedrukt

>./app
Hello World!

"Hallo wereld" als een bibliotheek

Dit voorbeeld laat zien hoe het programma "Hello World" als een bibliotheek kan worden gebruikt en hoe het kan worden gekoppeld aan andere doelen.

Stel dat we dezelfde set bron- / koptekstbestanden hebben als in het http://www.riptutorial.com/cmake/example/22391/-hello-world--with-multiple-source-files voorbeeld. In plaats van te bouwen vanuit meerdere bronbestanden, kunnen we eerst foo.cpp implementeren als een bibliotheek met behulp van add_library() en deze vervolgens koppelen aan het hoofdprogramma met target_link_libraries() .

We wijzigen 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)

en door dezelfde stappen te volgen, krijgen we hetzelfde resultaat.