cmakeAan de slag met cmake


Opmerkingen

CMake is een hulpmiddel voor het definiëren en beheren van code-builds, voornamelijk voor C ++.

CMake is een platformonafhankelijke tool; het idee is om een enkele definitie te hebben van hoe het project is gebouwd - wat zich vertaalt in specifieke builddefinities voor elk ondersteund platform.

Dit wordt bereikt door te koppelen met verschillende platformspecifieke buildsystemen; CMake is een tussenstap die build-input genereert voor verschillende specifieke platforms. Op Linux genereert CMake Makefiles; op Windows kan het Visual Studio-projecten genereren, enzovoort.

CMakeLists.txt wordt gedefinieerd in CMakeLists.txt bestanden - één in elke map van de broncode. Het CMakeLists bestand van elke map definieert wat het buildsysteem moet doen in die specifieke map. Het definieert ook welke submappen CMake ook moet verwerken.

Typische acties zijn onder meer:

  • Bouw een bibliotheek of een uitvoerbaar bestand uit enkele van de bronbestanden in deze map.
  • Voeg een bestandspad toe aan het include-pad dat tijdens het bouwen wordt gebruikt.
  • Definieer variabelen die het buildsysteem zal gebruiken in deze map en in zijn submappen.
  • Genereer een bestand op basis van de specifieke build-configuratie.
  • Zoek een bibliotheek die zich ergens in de bronstructuur bevindt.

De uiteindelijke CMakeLists bestanden kunnen heel duidelijk en eenvoudig zijn, omdat elk zo beperkt in omvang is. Elk behandelt slechts zoveel van de build als aanwezig is in de huidige map.

Zie de documentatie en de zelfstudie van CMake voor officiële bronnen over CMake.

versies

Versie Publicatiedatum
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

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

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

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

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 
 

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.