CMakeLists begrijpen

Grip krijgen op hoe bestanden CMakeLists.txt werken

CMake

In ons inleidende handboek gebruiken we CMake als het bouwsysteem voor onze toepassing, maar we hebben slechts alleen wat meer aandacht besteed aan een van onze bestanden CMakeLists.txt. Hier gaan we het in meer detail hebben over dit werkt.

CMake is nuttig omdat het ons is staat stelt om veel van de zaken die gedaan moeten worden alvorens te compileren te automatiseren.

CMakeLists.txt

Misschien herinnert u zich dit bestand CMakeLists.txt uit de eerste handleiding:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
cmake_minimum_required(VERSION 3.16)
project(helloworld)

find_package(ECM REQUIRED NO_MODULE)
set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDECompilerSettings NO_POLICY_SCOPE)

find_package(Qt${QT_MAJOR_VERSION} REQUIRED NO_MODULE COMPONENTS
    Core
    Quick
    Test
    Gui
    QuickControls2
    Widgets
)

find_package(KF${QT_MAJOR_VERSION} REQUIRED COMPONENTS
    Kirigami2
    I18n
    CoreAddons
)

add_subdirectory(src)

feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)

De eerste regel, cmake_minimum_required(VERSION 3.16) stelt de versie van CMake in die we willen aanroepen.

Daarna, definieert project(helloworld) de naam van het project.

Daarna krijgen we een sectie waar we een aantal noodzakelijke CMake en KDE-instellingen invoegen met gebruik van extra-cmake-modules. U zou zich nu niet te veel zorgen moeten maken over deze regels en we hoeven ze niet te wijzigen in deze handleiding.

De volgende sectie is belangrijk, omdat het specificeert welke afhankelijkheden we zullen inbrengen bij compileren. Laten we naar de eerste kijken:

11
12
13
14
15
16
17
18
find_package(Qt${QT_MAJOR_VERSION} REQUIRED NO_MODULE COMPONENTS
    Core
    Quick
    Test
    Gui
    QuickControls2
    Widgets
)

find_package() zoekt en laadt de externe component.
Het eerste woord is het framework, Qt. ${QT_MAJOR_VERSION} is een variabele voor het gemak geleverd door extra-cmake-modules die ons de te gebruiken Qt-versie laten kiezen, 5 of 6, afhankelijk van of we de CMake-vlag -DBUILD_WITH_QT6=ON gebruiken.
REQUIRED vertelt CMake dat deze afhankelijkheden inderdaad vereist zijn en dat het met een fout zal eindigen als het pakket niet gevonden kan worden.
NO_MODULE schakelt CMake naar de modus Config. Op dit moment maken we ons daar geen zorgen over.
COMPONENTS is een parameter die vooraf gaat aan de specifieke componenten van het framework dat we zullen invoegen.
Elk woord na COMPONENTS refereert naar een specifieke component.

Notitie

Als u zoekt om componenten in de lijst in de KDE API documentation aan uw toepassing toe te voegen, dan zou u de rechter zijbalk kunnen controleren op hoe de component met CMake toe te voegen. Bijvoorbeeld, voor Kirigami2 zult u iets vinden zoals find_package(KF5Kirigami2), dat met de toevoeging van extra-cmake-modules iets wordt als find_package(KF5 COMPONENTS Kirigami2).

Let goed op uw ingevoegde componenten, omdat weglaten van die gebruikt worden in onze code onze toepassing niet laten compileren.

De laatste regel laat CMake tonen welke pakketten het heeft gevonden. En bovendien dat add_subdirectory(src) CMake laat wijzen naar de map 'src/', waar het een ander bestand CMakeLists.txt vindt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
add_executable(helloworld)

target_sources(helloworld PRIVATE
    main.cpp
    resources.qrc
)

target_link_libraries(helloworld
    Qt${QT_MAJOR_VERSION}::Quick
    Qt${QT_MAJOR_VERSION}::Qml
    Qt${QT_MAJOR_VERSION}::Gui
    Qt${QT_MAJOR_VERSION}::QuickControls2
    Qt${QT_MAJOR_VERSION}::Widgets
    KF${QT_MAJOR_VERSION}::I18n
)

install(TARGETS helloworld ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})

Omdat het zwaarste gedaan wordt door het eerste bestand, is deze heel wat korter.

add_executable() zorgt voor genereren van het uitvoerbare bestand.
target_sources() laat ons bestanden toevoegen die gebruikt zullen worden door ons nieuwe uitvoerbare bestand.
target_link_libraries() koppelt dynamisch de bibliotheken, die gebruikt worden in onze code, aan ons uitvoerbare bestand. Kirigami is hier niet meegenomen omdat we alleen zijn QML-module gebruiken.
install() zet ons uitvoerbare bestand op zijn juiste plaats door ${KDE_INSTALL_TARGETS_DEFAULT_ARGS} te gebruiken, een gemaksvariabele geleverd door KDEInstallDirs in extra-cmake-modules die uitvoerbare bestanden en bibliotheken installeert op hun juiste plaats voor u zonder noodzaak het absolute pad te specificeren, overeenkomstig GNUInstallDirs.

Notitie

Merk op dat deze bibliotheken overeen zouden moeten komen met de componenten die we hebben ingevoegd in ons vorige bestand CMakeLists.txt - anders zullen deze componenten niet ingevoegd worden en zal onze toepassing niet compileren.

Deze opzet zal bruikbaar zijn bij ontwikkelen van de meeste Kirigami toepassingen.

Lijstweergaven

Bekijken wat main.cpp doet