cmake Handledning
Komma igång med cmake

Anmärkningar

versioner

CMake-installation

Gå till CMake nedladdningssida och få en binär för ditt operativsystem, t.ex. Windows, Linux eller Mac OS X. I Windows dubbelklickar du på den binära för att installera. På Linux kör binär från en terminal.

På Linux kan du också installera paketen från distributionens pakethanterare. På Ubuntu 16.04 kan du installera kommandoraden och den grafiska applikationen med:

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

På FreeBSD kan du installera kommandoraden och den Qt-baserade grafiska applikationen med:

pkg install cmake
pkg install cmake-gui

Om du använder en av de pakethanterare som finns tillgängliga för att installera din programvara på Mac OSX, var den mest anmärkningsvärda MacPorts ( MacPorts ) och Homebrew ( Homebrew ), kan du också installera CMake via en av dem. Om du till exempel använder MacPorts skriver du följande

sudo port install cmake  

installerar CMake, om du använder Homebrew-paketet kommer du att skriva

brew install cmake

När du har installerat CMake kan du enkelt kontrollera genom att göra följande

cmake --version

Du bör se något liknande följande

cmake version 3.5.1

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

Växla mellan byggtyper, t.ex. felsökning och släpp

CMake känner till flera byggtyper, som vanligtvis påverkar standardkompilerings- och länkparametrar (som felsökningsinformation som skapas) eller alternativa kodvägar.

Som standard kan CMake hantera följande byggtyper:

• Debug : Vanligtvis en klassisk felsökning inklusive felsökningsinformation, ingen optimering etc.
• Release : Din typiska utgåva bygger utan felsökningsinformation och fullständig optimering.
• RelWithDebInfo:: Samma som Release , men med felsökningsinformation.
• MinSizeRel : En speciell release- konstruktion optimerad för storlek.

Hur konfigurationer hanteras beror på vilken generator som används.

Vissa generatorer (som Visual Studio) stöder flera konfigurationer. CMake genererar alla konfigurationer samtidigt och du kan välja från IDE eller använda --config CONFIG (med cmake --build ) vilken konfiguration du vill bygga. För dessa generatorer kommer CMake att göra sitt bästa för att generera en build-katalogstruktur så att filer från olika konfigurationer inte trampar på varandra.

Generatorer som bara stöder en enda konfiguration (som Unix Makefiles) fungerar annorlunda. Här bestäms den för närvarande aktiva konfigurationen av värdet på CMake-variabeln CMAKE_BUILD_TYPE .

Till exempel kan man välja följande kommandoradskommandon för att välja en annan byggtyp:

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

Ett CMake-skript bör undvika att ställa in CMAKE_BUILD_TYPE själv, eftersom det i allmänhet anses användarnas ansvar att göra det.

För enskonfigurerade generatorer kräver omkoppling av konfigurationen CMake igen. En efterföljande byggnad kommer sannolikt att skriva över objektfiler som produceras av den tidigare konfigurationen.

Enkelt "Hello World" -projekt

Med tanke på en C ++ main.cpp definierar en huvudfunktion main() , kommer en åtföljande CMakeLists.txt fil (med följande innehåll) instruera CMake att generera lämpliga bygginstruktioner för det aktuella systemet och standard C ++ -kompileraren.

main.cpp ( C ++ Hello World Exempel )

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

Se den live på Coliru

1. cmake_minimum_required(VERSION 2.4) anger en minimum CMake-version som krävs för att utvärdera det aktuella skriptet.

2. project(hello_world) startar ett nytt CMake-projekt. Detta utlöser mycket intern CMake-logik, speciellt detekteringen av standardkompileraren C och C ++.

3. Med add_executable(app main.cpp) en build target- app som kommer att åberopa den konfigurerade kompilatorn med några standardflaggor för den aktuella inställningen för att kompilera en körbar app från den givna källfilen main.cpp .

Kommandorad (In-source-Build, rekommenderas inte)

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

cmake . gör kompilatordetekteringen, utvärderar CMakeLists.txt i det angivna . katalog och genererar byggmiljön i den aktuella arbetskatalogen.

cmake --build . kommando är en abstraktion för nödvändigt bygga / ringa samtal.

Kommandorad (out-of-source, rekommenderas)

För att hålla din källkod ren från alla byggföremål måste du göra "out-of-source".

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

Eller så kan CMake abstrahera dina plattformsskals grundläggande kommandon från ovanstående exempel:

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

"Hello World" med flera källfiler

Först kan vi specificera katalogerna för headerfiler med include_directories() , sedan måste vi ange motsvarande källfiler för målet som kan köras med add_executable() , och vara säker på att det finns exakt en huvudfunktion main() i källfilerna.

Följande är ett enkelt exempel, alla filer antas placeras i katalogen 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

Vi kan följa samma procedur i exemplet ovan för att bygga vårt projekt. Sedan skrivs exekverande app ut

>./app
Hello World!

"Hello World" som ett bibliotek

Detta exempel visar hur man implementerar programmet "Hello World" som ett bibliotek och hur man kopplar det till andra mål.

Säg att vi har samma uppsättning käll- / sidfiler som i exemplet http://www.riptutorial.com/cmake/example/22391/-hello-world--med-multiple-source-files . Istället för att bygga från flera källfiler kan vi först distribuera foo.cpp som ett bibliotek genom att använda add_library() och sedan koppla det till huvudprogrammet med target_link_libraries() .

Vi ändrar CMakeLists.txt till

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)

och efter samma steg får vi samma resultat.