CMake eta C++ betiko anaiak dira

Garapenean, konpiladoreak aldatzea, moduak eraikitzea, mendekotasun bertsioak, analisi estatikoak egitea, errendimendua neurtzea, estaldura biltzea, dokumentazioa sortzea eta abar gustatzen zait. Eta oso maite dut CMake, nahi dudana egiteko aukera ematen didalako.

Askok errieta egiten diote CMake, eta askotan merezita, baina begiratuz gero, ez dago hain txarra, baina azkenaldian ez da batere gaizki, eta garapenaren norabidea nahiko positiboa da.

Ohar honetan, esan nahi dizut zein erraza den C++ goiburuko liburutegi bat CMake sistema batean antolatzea funtzionaltasun hau lortzeko:

1. muntaia;
2. Autorun probak;
3. Kode estalduraren neurketa;
4. instalazioa;
5. Autodokumentazioa;
6. Lineako sandbox sortzea;
7. Analisi estatikoa.

Nork dagoeneko ulertzen ditu pros eta si-make besterik ez deskargatu proiektuaren txantiloia eta hasi erabiltzen.

Edukia

1. Proiektua barrutik
   1. Proiektuaren egitura
   2. CMake fitxategi nagusia (./CMakeLists.txt)
      1. Proiektuaren informazioa
      2. Proiektuaren aukerak
      3. Konpilazio aukerak
      4. Helburu nagusia
      5. Instalazio-
      6. probak
      7. Dokumentazioa
      8. Online sandbox
   3. Probetarako gidoia (test/CMakeLists.txt)
      1. Testing
      2. Estaldura
   4. Dokumentazio-gidoia (doc/CMakeLists.txt)
   5. Lineako sandboxerako gidoia (online/CMakeLists.txt)
2. proiektua kanpoan
   1. muntaia
      1. Sorkuntza
      2. muntaia
   2. aukera
      1. MYLIB_COVERAGE
      2. MYLIB_TESTING
      3. MYLIB_DOXYGEN_LANGUAGE
   3. muntaia helburuak
      1. Lehenespenez
      2. mylib-unitate-probak
      3. egiaztatu
      4. estaldura
      5. doc
      6. makila-kutxa
   4. Примеры
3. Tresnak
4. Analisi Estatikoa
5. afterword

Proiektua barrutik

Proiektuaren egitura

.
├── CMakeLists.txt
├── README.en.md
├── README.md
├── doc
│   ├── CMakeLists.txt
│   └── Doxyfile.in
├── include
│   └── mylib
│       └── myfeature.hpp
├── online
│   ├── CMakeLists.txt
│   ├── mylib-example.cpp
│   └── wandbox.py
└── test
    ├── CMakeLists.txt
    ├── mylib
    │   └── myfeature.cpp
    └── test_main.cpp

Honek, batez ere, CMake script-ak antolatzeko moduari erreparatuko dio, beraz, zehatz-mehatz aztertuko dira. Gainerako fitxategiak edonork ikus ditzake zuzenean. txantiloi proiektuaren orrian.

CMake fitxategi nagusia (./CMakeLists.txt)

Proiektuaren informazioa

Lehenik eta behin, CMake sistemaren nahi duzun bertsioa eskatu behar duzu. CMake garatzen da, komandoen sinadurak aldatzen dira, portaera baldintza desberdinetan. CMake-k bertatik zer nahi dugun berehala ulertu dezan, berehala konpondu behar ditugu gure eskakizunak.

cmake_minimum_required(VERSION 3.13)

Ondoren, gure proiektua adierazten dugu, bere izena, bertsioa, erabilitako hizkuntzak, etab. команду project).

Kasu honetan, zehaztu hizkuntza CXX (horrek C++ esan nahi du), CMake-k C konpilatzaile bat bilatzeko trabarik izan ez dezan (lehenespenez, bi hizkuntza sartzen dira CMake-n: C eta C++).

project(Mylib VERSION 1.0 LANGUAGES CXX)

Hemen berehala egiaztatu dezakezu gure proiektua azpiproiektu gisa beste proiektu batean sartuta dagoen. Horrek asko lagunduko du etorkizunean.

get_directory_property(IS_SUBPROJECT PARENT_DIRECTORY)

Proiektuaren aukerak

Azter ditzagun bi aukera.

Lehenengo aukera da MYLIB_TESTING - unitate-probak desgaitzeko. Baliteke hori beharrezkoa izatea probetan dena ondo dagoela ziur baldin bagara, eta, adibidez, gure proiektua instalatu edo paketatu nahi badugu. Edo gure proiektua azpiproiektu gisa sartzen da; kasu honetan, gure proiektuaren erabiltzaileari ez zaio interesatzen gure probak egitea. Ez dituzu erabiltzen dituzun menpekotasunak probatzen, ezta?

option(MYLIB_TESTING "Включить модульное тестирование" ON)

Horrez gain, aparteko aukera bat egingo dugu MYLIB_COVERAGE kode estaldura probekin neurtzeko, baina tresna osagarriak beharko ditu, beraz, esplizituki gaitu beharko duzu.

option(MYLIB_COVERAGE "Включить измерение покрытия кода тестами" OFF)

Konpilazio aukerak

Jakina, programatzaile politak gara, beraz, konpiladorearen konpilazio garaiko diagnostikoen maila maximoa nahi dugu. Sagu bakar bat ere ez da igaroko.

add_compile_options(
    -Werror

    -Wall
    -Wextra
    -Wpedantic

    -Wcast-align
    -Wcast-qual
    -Wconversion
    -Wctor-dtor-privacy
    -Wenum-compare
    -Wfloat-equal
    -Wnon-virtual-dtor
    -Wold-style-cast
    -Woverloaded-virtual
    -Wredundant-decls
    -Wsign-conversion
    -Wsign-promo
)

Luzapenak ere desgaituko ditugu C ++ hizkuntza estandarra guztiz betetzeko. Lehenespenez gaituta daude CMake-n.

if(NOT CMAKE_CXX_EXTENSIONS)
    set(CMAKE_CXX_EXTENSIONS OFF)
endif()

Helburu nagusia

Gure liburutegia goiburuko fitxategiez bakarrik dago osatuta, hau da, ez dugu inolako irteerarik liburutegi estatiko edo dinamiko moduan. Bestalde, gure liburutegia kanpotik erabiltzeko, instalatu behar duzu, sisteman aurkitu eta zure proiektura konektatu eta aldi berean goiburu hauek ere bai. gisa, ziurrenik, propietate gehigarri batzuk.

Horretarako, interfaze-liburutegi bat sortzen dugu.

add_library(mylib INTERFACE)

Goiburuak gure interfazearen liburutegira lotzen ditugu.

CMake-ren erabilera modernoak, modan eta gazteak esan nahi du goiburuak, propietateak, etab. helburu bakar baten bidez transmititzen da. Beraz, nahikoa da esatea target_link_libraries(target PRIVATE dependency), eta xedearekin lotutako goiburu guztiak dependency, xedeari dagozkion iturrietarako eskuragarri egongo da target. Eta ez duzu beharrik [target_]include_directories. Hau behean erakutsiko da analizatzerakoan Unitate-probetarako CMake scripta.

Deiturikoak ere arreta jartzea merezi du. выражения-генераторы: $<...>.

Komando honek behar ditugun goiburuak gure interfaze liburutegiarekin lotzen ditu, eta gure liburutegia CMake hierarkia bereko edozein helbururekin konektatuta badago, direktorioko goiburuak harekin lotuko dira. ${CMAKE_CURRENT_SOURCE_DIR}/include, eta gure liburutegia sisteman instalatuta badago eta komandoa erabiliz beste proiektu batera konektatuta badago find_package, orduan direktorioko goiburuak harekin lotuko dira include instalazio direktorioari dagokionez.

target_include_directories(mylib INTERFACE
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>
)

Ezarri hizkuntza estandarra. Noski, azkena. Aldi berean, estandarra sartzeaz gain, gure liburutegia erabiliko dutenei ere banatzen diegu. Hau multzoko propietateak kategoria bat izatea lortzen da INTERFACE (Ikus target_compile_features komandoa).

target_compile_features(mylib INTERFACE cxx_std_17)

Gure liburutegirako alias bat lortzen dugu. Eta edertasunagatik, "namespace" berezi batean egongo da. Hau erabilgarria izango da gure liburutegian modulu desberdinak agertzen direnean, eta elkarrengandik independentean konektatzera joaten garenean. Bustan bezala, adibidez.

add_library(Mylib::mylib ALIAS mylib)

Instalazio-

Gure goiburuak sisteman instalatzen. Hemen dena sinplea da. Goiburu guztiak dituen karpetak direktorioa sartu behar duela esaten dugu include instalazioaren kokapenari dagokionez.

install(DIRECTORY include/mylib DESTINATION include)

Ondoren, eraikitze-sistemari hirugarrenen proiektuetan komandoari dei egin ahal izan nahi diogula esaten diogu find_package(Mylib) eta helburu bat lortu Mylib::mylib.

install(TARGETS mylib EXPORT MylibConfig)
install(EXPORT MylibConfig NAMESPACE Mylib:: DESTINATION share/Mylib/cmake)

Honela ulertu behar da ondorengo doinua. Alboko proiektu batean komandoari deitzen diogu find_package(Mylib 1.2.3 REQUIRED), eta, aldi berean, instalatutako liburutegiaren benetako bertsioa bertsioarekin bateraezina izango da 1.2.3, CMake-k automatikoki errore bat sortuko du. Hau da, ez duzu bertsioen jarraipena eskuz egin beharko.

include(CMakePackageConfigHelpers)
write_basic_package_version_file("${PROJECT_BINARY_DIR}/MylibConfigVersion.cmake"
    VERSION
        ${PROJECT_VERSION}
    COMPATIBILITY
        AnyNewerVersion
)
install(FILES "${PROJECT_BINARY_DIR}/MylibConfigVersion.cmake" DESTINATION share/Mylib/cmake)

probak

Probak esplizituki desgaitzen badira dagokion aukera edo gure proiektua azpiproiektu bat da, hau da, beste CMake proiektu batera konektatuta dago komandoa erabiliz add_subdirectory, ez gara hierarkian beherago joaten, eta probak sortzeko eta exekutatzeko komandoak deskribatzen dituen scripta ez da abiarazten.

if(NOT MYLIB_TESTING)
    message(STATUS "Тестирование проекта Mylib выключено")
elseif(IS_SUBPROJECT)
    message(STATUS "Mylib не тестируется в режиме подмодуля")
else()
    add_subdirectory(test)
endif()

Dokumentazioa

Azpiproiektu baten kasuan ere ez da dokumentaziorik sortuko.

if(NOT IS_SUBPROJECT)
    add_subdirectory(doc)
endif()

Online sandbox

Era berean, azpiproiektuak ez du sareko sandboxik ere izango.

if(NOT IS_SUBPROJECT)
    add_subdirectory(online)
endif()

Probetarako gidoia (test/CMakeLists.txt)

Testing

Lehenik eta behin, nahi duzun proba-esparrua duen pakete bat aurkituko dugu (ordeztu zure gogokoena).

find_package(doctest 2.3.3 REQUIRED)

Testekin gure fitxategi exekutagarria sortzen dugu. Normalean, zuzenean bitar exekutagarrira, funtzioa egongo den fitxategia bakarrik gehitzen dut main.

add_executable(mylib-unit-tests test_main.cpp)

Eta probak berak deskribatzen diren fitxategiak, geroago gehitzen ditut. Baina ez da beharrezkoa hori egitea.

target_sources(mylib-unit-tests PRIVATE mylib/myfeature.cpp)

Menpekotasunak lotzen ditugu. Kontuan izan behar genituen CMake helburuak bakarrik erantsi genituela gure bitarrari, eta ez genuela komandoari deitu target_include_directories. Test-esparruko goiburuak eta gure Mylib::mylib, baita eraikitzeko aukerak ere (gure kasuan, C++ hizkuntza estandarra) helburu hauekin batera arakatu ziren.

target_link_libraries(mylib-unit-tests
    PRIVATE
        Mylib::mylib
        doctest::doctest
)

Azkenik, helburu finko bat sortzen dugu, zeinaren "eraiketa" probak exekutatzen direnen baliokidea den, eta helburu hau lehenetsitako eraikuntzara gehitzen dugu (hau atributuaren ardura da. ALL). Horrek esan nahi du lehenetsitako eraikuntzak probak abiaraziko dituela, hots, ez ditugula exekutatzen ahaztuko.

add_custom_target(check ALL COMMAND mylib-unit-tests)

Estaldura

Ondoren, aktibatu kodea estalduraren neurketa, dagokion aukera ezarrita badago. Ez naiz xehetasunetan sartuko, estaldura neurtzeko tresnarekin lotuta baitaude CMakerekin baino. Garrantzitsua da soilik emaitzek helburu bat sortuko dutela coverage, eta horrekin komenigarria da estaldura neurtzen hastea.

find_program(GCOVR_EXECUTABLE gcovr)
if(MYLIB_COVERAGE AND GCOVR_EXECUTABLE)
    message(STATUS "Измерение покрытия кода тестами включено")

    target_compile_options(mylib-unit-tests PRIVATE --coverage)
    target_link_libraries(mylib-unit-tests PRIVATE gcov)

    add_custom_target(coverage
        COMMAND
            ${GCOVR_EXECUTABLE}
                --root=${PROJECT_SOURCE_DIR}/include/
                --object-directory=${CMAKE_CURRENT_BINARY_DIR}
        DEPENDS
            check
    )
elseif(MYLIB_COVERAGE AND NOT GCOVR_EXECUTABLE)
    set(MYLIB_COVERAGE OFF)
    message(WARNING "Для замеров покрытия кода тестами требуется программа gcovr")
endif()

Dokumentazio-gidoia (doc/CMakeLists.txt)

Doxygen aurkitu.

find_package(Doxygen)

Ondoren, hizkuntza duen aldagaia erabiltzaileak ezartzen duen egiaztatuko dugu. Bai bada, orduan ez dugu ukitzen, ez bada, errusiera hartzen dugu. Ondoren, Doxygen sistemaren fitxategiak konfiguratuko ditugu. Beharrezko aldagai guztiak, hizkuntza barne, horra iristen dira konfigurazio prozesuan (ikus. команду configure_file).

Ondoren, helburu bat sortzen dugu doc, dokumentazioa sortzen hasiko dena. Dokumentazioa sortzea garapen-prozesuan beharrik handiena ez denez, xedea ez da lehenespenez sartuko, esplizituki exekutatu beharko da.

if (Doxygen_FOUND)
    if (NOT MYLIB_DOXYGEN_LANGUAGE)
        set(MYLIB_DOXYGEN_LANGUAGE Russian)
    endif()
    message(STATUS "Doxygen documentation will be generated in ${MYLIB_DOXYGEN_LANGUAGE}")
    configure_file(Doxyfile.in Doxyfile)
    add_custom_target(doc COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
endif ()

Lineako sandboxerako gidoia (online/CMakeLists.txt)

Hemen hirugarren Python aurkituko dugu eta helburu bat sortuko dugu wandbox, zerbitzuaren APIari dagokion eskaera sortzen duena Makila-kutxa, eta bidaltzen du. Erantzun gisa, amaitutako sandboxerako esteka bat dator.

find_program(PYTHON3_EXECUTABLE python3)
if(PYTHON3_EXECUTABLE)
    set(WANDBOX_URL "https://wandbox.org/api/compile.json")

    add_custom_target(wandbox
        COMMAND
            ${PYTHON3_EXECUTABLE} wandbox.py mylib-example.cpp "${PROJECT_SOURCE_DIR}" include |
            curl -H "Content-type: application/json" -d @- ${WANDBOX_URL}
        WORKING_DIRECTORY
            ${CMAKE_CURRENT_SOURCE_DIR}
        DEPENDS
            mylib-unit-tests
    )
else()
    message(WARNING "Для создания онлайн-песочницы требуется интерпретатор ЯП python 3-й версии")
endif()

proiektua kanpoan

Orain ikus dezagun nola erabili dena.

muntaia

Proiektu hau eraikitzea, CMake build sistemako beste edozein proiektu bezala, bi fase ditu:

Sorkuntza

cmake -S путь/к/исходникам -B путь/к/сборочной/директории [опции ...]

Goiko komandoak CMake-ren bertsio zaharrago baten ondorioz funtzionatu ez badu, saiatu ezabatzen -S:

cmake путь/к/исходникам -B путь/к/сборочной/директории [опции ...]

Aukerei buruz gehiago.

Proiektua eraikitzea

cmake --build путь/к/сборочной/директории [--target target]

Batzarraren helburuei buruz gehiago.

aukera

MYLIB_COVERAGE

cmake -S ... -B ... -DMYLIB_COVERAGE=ON [прочие опции ...]

Helburua barne coverage, eta horrekin kode-estaldura proben bidez neurtzen has zaitezke.

MYLIB_TESTING

cmake -S ... -B ... -DMYLIB_TESTING=OFF [прочие опции ...]

Unitate-probaren eraikuntza eta helburua desaktibatzeko aukera eskaintzen du check. Ondorioz, proben bidezko kodea estaldura neurtzea desaktibatu egiten da (ikus MYLIB_COVERAGE).

Gainera, probak automatikoki desgaitzen dira proiektua beste proiektu batera konektatzen bada komandoa erabiliz azpiproiektu gisa add_subdirectory.

MYLIB_DOXYGEN_LANGUAGE

cmake -S ... -B ... -DMYLIB_DOXYGEN_LANGUAGE=English [прочие опции ...]

Helburuak sortzen duen dokumentazioaren hizkuntza aldatzen du doc emandakoari. Eskuragarri dauden hizkuntzen zerrenda ikusteko, ikus Doxygen webgunea.

Lehenespenez, errusiera gaituta dago.

muntaia helburuak

Lehenespenez

cmake --build path/to/build/directory
cmake --build path/to/build/directory --target all

Helburua zehazten ez bada (helburuaren baliokidea dena all), posible den guztia biltzen du, eta xedeari ere deitzen dio check.

mylib-unitate-probak

cmake --build path/to/build/directory --target mylib-unit-tests

Unitate-probak biltzen ditu. Lehenespenez gaituta.

egiaztatu

cmake --build путь/к/сборочной/директории --target check

Eraikitako probak (eraikitzen ditu dagoeneko ez bada) exekutatzen ditu. Lehenespenez gaituta.

Ikusi ere mylib-unit-tests.

estaldura

cmake --build путь/к/сборочной/директории --target coverage

Exekutatzen (exekutatzen, oraindik ez bada) unitate-probak aztertzen ditu kode-estaldurarako, programa erabiliz proben bidez gcovr.

Estaldura irteerak honelako itxura izango du:

------------------------------------------------------------------------------
                           GCC Code Coverage Report
Directory: /path/to/cmakecpptemplate/include/
------------------------------------------------------------------------------
File                                       Lines    Exec  Cover   Missing
------------------------------------------------------------------------------
mylib/myfeature.hpp                            2       2   100%   
------------------------------------------------------------------------------
TOTAL                                          2       2   100%
------------------------------------------------------------------------------

Helburua aukera gaituta dagoenean bakarrik dago erabilgarri. MYLIB_COVERAGE.

Ikusi ere check.

doc

cmake --build путь/к/сборочной/директории --target doc

Sistema erabiliz kodearen dokumentazioa sortzen hasten da Doxygen.

makila-kutxa

cmake --build путь/к/сборочной/директории --target wandbox

Zerbitzuaren erantzuna honelakoa da:

{
    "permlink" :    "QElvxuMzHgL9fqci",
    "status" :  "0",
    "url" : "https://wandbox.org/permlink/QElvxuMzHgL9fqci"
}

Zerbitzua horretarako erabiltzen da. Makila-kutxa. Ez dakit nola gomazko zerbitzariak dituzten, baina uste dut ez zenukeela funtzio hau abusatu behar.

Примеры

Eraiki proiektua arazketa moduan estaldura neurtuz

cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DCMAKE_BUILD_TYPE=Debug -DMYLIB_COVERAGE=ON
cmake --build путь/к/сборочной/директории --target coverage --parallel 16

Proiektu bat instalatzea aldez aurretik eraiki eta probatu gabe

cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DMYLIB_TESTING=OFF -DCMAKE_INSTALL_PREFIX=путь/к/установойной/директории
cmake --build путь/к/сборочной/директории --target install

Emandako konpiladoreak kaleratze moduan eraiki

cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=g++-8 -DCMAKE_PREFIX_PATH=путь/к/директории/куда/установлены/зависимости
cmake --build путь/к/сборочной/директории --parallel 4

Dokumentazioa ingelesez sortzea

cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DCMAKE_BUILD_TYPE=Release -DMYLIB_DOXYGEN_LANGUAGE=English
cmake --build путь/к/сборочной/директории --target doc

Tresnak

1. CMake 3.13

   Izan ere, CMake 3.13 bertsioa laguntza honetan deskribatutako kontsolaren komando batzuk exekutatzeko soilik behar da. CMake scripten sintaxiaren ikuspuntutik, 3.8 bertsioa nahikoa da belaunaldiari beste modu batzuetara deitzen bazaio.

2. Proba Liburutegia doktoretza

   Probak desgaitu daitezke (ikus опцию MYLIB_TESTING).

3. Doxygen

   Dokumentazioa sortuko den hizkuntza aldatzeko, aukera bat dago MYLIB_DOXYGEN_LANGUAGE.

4. PL interpretea Python 3

   Sorkuntza automatikorako online sandboxes.

Analisi Estatikoa

CMake-ren eta tresna on pare batekin, azterketa estatikoa eskain dezakezu gutxieneko bitxikeriarekin.

Cppcheck

CMake-n integratutako analisi estatikorako tresnarako laguntza Cppcheck.

Horretarako, erabili aukera CMAKE_CXX_CPPCHECK:

cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_CPPCHECK="cppcheck;--enable=all;-Iпуть/к/исходникам/include"

Horren ondoren, analisi estatikoa automatikoki abiaraziko da iturrien konpilazioan eta birkonpilazioan. Ez da aparteko ezer egin behar.

Deika

Tresna zoragarri batekin scan-build Analisi estatikoa ere exekutatu dezakezu denbora gutxian:

scan-build cmake -S путь/к/исходникам -B путь/к/сборочной/директории -DCMAKE_BUILD_TYPE=Debug
scan-build cmake --build путь/к/сборочной/директории

Hemen, Cppcheck-en kasuan ez bezala, eraikuntza exekutatu behar da scan-build.

afterword

CMake oso sistema indartsua eta malgua da, eta gustu eta kolore guztietarako funtzionalitateak ezartzeko aukera ematen du. Eta, zenbaitetan sintaxiak asko uzten badu ere, deabrua oraindik ez da margotua bezain ikaragarria. Erabili CMake build sistema gizartearen eta osasunaren mesederako.

→ Deskargatu proiektuaren txantiloia

Iturria: www.habr.com