🥇CMake და C++ სამუდამოდ ძმები არიან

განვითარების დროს მე მომწონს შემდგენელების შეცვლა, რეჟიმების აგება, დამოკიდებულების ვერსიების გაკეთება, სტატიკური ანალიზის ჩატარება, შესრულების გაზომვა, დაფარვის შეგროვება, დოკუმენტაციის გენერირება და ა.შ. და მე ნამდვილად მიყვარს CMake, რადგან ის მაძლევს საშუალებას გავაკეთო ყველაფერი, რაც მინდა.

ბევრი ადამიანი აკრიტიკებს CMake-ს და ხშირად ამასაც დამსახურებულად, მაგრამ თუ დააკვირდებით, ყველაფერი ასე ცუდად არ არის და ახლახან ცუდი არ არის, განვითარების მიმართულება კი საკმაოდ დადებითია.

ამ ჩანაწერში მინდა გითხრათ, თუ როგორ უნდა მოაწყოთ სათაურის ბიბლიოთეკა C++-ში CMake სისტემაში შემდეგი ფუნქციონირების მისაღებად:

ასამბლეა;
ავტომატური გაშვების ტესტები;
კოდის დაფარვის გაზომვა;
მონტაჟი;
ავტომატური დოკუმენტაცია;
ონლაინ sandbox თაობა;
სტატიკური ანალიზი.

ვისაც უკვე ესმის უპირატესობები და C-make შეუძლია უბრალოდ ჩამოტვირთეთ პროექტის შაბლონი და დაიწყე მისი გამოყენება.

პროექტი შიგნიდან

პროექტის სტრუქტურა

.
├── 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

ჩვენ ძირითადად ვისაუბრებთ იმაზე, თუ როგორ უნდა მოაწყოთ CMake სკრიპტები, ამიტომ მათ დეტალურად განვიხილავთ. ნებისმიერს შეუძლია დანარჩენი ფაილების პირდაპირ ნახვა შაბლონის პროექტის გვერდზე.

მთავარი CMake ფაილი (./CMakeLists.txt)

პროექტის ინფორმაცია

უპირველეს ყოვლისა, თქვენ უნდა მოითხოვოთ CMake სისტემის საჭირო ვერსია. CMake ვითარდება, იცვლება ბრძანების ხელმოწერები და ქცევა სხვადასხვა პირობებში. იმისათვის, რომ CMake-მ დაუყოვნებლივ გაიგოს რა გვინდა მისგან, ჩვენ დაუყოვნებლივ უნდა ჩავწეროთ მასზე ჩვენი მოთხოვნები.

cmake_minimum_required(VERSION 3.13)

შემდეგ ჩვენ დავნიშნავთ ჩვენს პროექტს, მის სახელს, ვერსიას, გამოყენებულ ენებს და ა.შ. (იხ. команду project).

ამ შემთხვევაში ჩვენ აღვნიშნავთ ენას CXX (და ეს ნიშნავს C++) ისე, რომ CMake არ დაიძაბოს და არ მოძებნოს C ენის შემდგენელი (ნაგულისხმევად, CMake მოიცავს ორ ენას: C და C++).

project(Mylib VERSION 1.0 LANGUAGES CXX)

აქ შეგიძლიათ დაუყოვნებლივ შეამოწმოთ შედის თუ არა ჩვენი პროექტი სხვა პროექტში, როგორც ქვეპროექტი. ეს ძალიან დაეხმარება მომავალში.

get_directory_property(IS_SUBPROJECT PARENT_DIRECTORY)

პროექტის პარამეტრები

ჩვენ შემოგთავაზებთ ორ ვარიანტს.

პირველი ვარიანტი არის MYLIB_TESTING - ერთეულის ტესტების გამორთვა. ეს შეიძლება იყოს საჭირო, თუ დარწმუნებული ვართ, რომ ყველაფერი რიგზეა ტესტებთან დაკავშირებით, მაგრამ ჩვენ მხოლოდ გვინდა, მაგალითად, დავაინსტალიროთ ან შეფუთოთ ჩვენი პროექტი. ან ჩვენი პროექტი შედის ქვეპროექტად - ამ შემთხვევაში ჩვენი პროექტის მომხმარებელი არ არის დაინტერესებული ჩვენი ტესტების გაშვებით. თქვენ არ ამოწმებთ დამოკიდებულებებს, რომლებსაც იყენებთ, არა?

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

გარდა ამისა, ჩვენ გავაკეთებთ ცალკე ვარიანტს MYLIB_COVERAGE კოდის დაფარვის ტესტებით გაზომვისთვის, მაგრამ ამას დასჭირდება დამატებითი ხელსაწყოები, ამიტომ საჭიროა მისი ცალსახად ჩართვა.

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

კომპილაციის ვარიანტები

რა თქმა უნდა, ჩვენ მაგარი პლუს პროგრამისტები ვართ, ამიტომ გვსურს კომპილაციის დროის დიაგნოსტიკის მაქსიმალური დონე კომპილატორისგან. არც ერთი თაგვი არ გაცურდება.

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
)

ჩვენ ასევე გავაუქმებთ გაფართოებებს, რათა სრულად შეესაბამებოდეს C++ ენის სტანდარტს. ისინი ჩართულია ნაგულისხმევად CMake-ში.

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

მთავარი მიზანი

ჩვენი ბიბლიოთეკა შედგება მხოლოდ სათაურის ფაილებისგან, რაც ნიშნავს, რომ ჩვენ არ გვაქვს გამონაბოლქვი სტატიკური ან დინამიური ბიბლიოთეკების სახით. მეორეს მხრივ, ჩვენი ბიბლიოთეკის გარეგნულად გამოსაყენებლად, საჭიროა მისი დაინსტალირება, სისტემაში შესამჩნევი და დაკავშირებული თქვენს პროექტთან, და ამავე დროს, იგივე სათაურები, ასევე, შესაძლოა, რამდენიმე დამატებითი, მას ერთვის თვისებები.

ამ მიზნით, ჩვენ ვქმნით ინტერფეისის ბიბლიოთეკას.

add_library(mylib INTERFACE)

ჩვენ ვამაგრებთ სათაურებს ჩვენს ინტერფეისის ბიბლიოთეკასთან.

CMake-ის თანამედროვე, მოდური, ახალგაზრდული გამოყენება გულისხმობს, რომ სათაურები, თვისებები და ა.შ. გადაცემულია ერთი სამიზნის მეშვეობით. ამიტომ საკმარისია იმის თქმა target_link_libraries(target PRIVATE dependency)და ყველა სათაური, რომელიც ასოცირდება სამიზნესთან dependency, ხელმისაწვდომი იქნება სამიზნის კუთვნილი წყაროებისთვის target. და არცერთი არ გჭირდება [target_]include_directories. ეს ნაჩვენები იქნება ქვემოთ ანალიზში CMake სკრიპტი ერთეული ტესტებისთვის.

ასევე ღირს ყურადღების მიქცევა ე.წ. выражения-генераторы: $<...>.

ეს ბრძანება აკავშირებს ჩვენთვის საჭირო სათაურებს ჩვენს ინტერფეისის ბიბლიოთეკასთან, და თუ ჩვენი ბიბლიოთეკა დაკავშირებულია ნებისმიერ სამიზნესთან იმავე CMake იერარქიაში, მაშინ სათაურები დირექტორიაში ასოცირებული იქნება მასთან. ${CMAKE_CURRENT_SOURCE_DIR}/includeდა თუ ჩვენი ბიბლიოთეკა დაინსტალირებულია სისტემაზე და დაკავშირებულია სხვა პროექტთან ბრძანების გამოყენებით find_package, მაშინ სათაურები დირექტორიადან იქნება დაკავშირებული მასთან include ინსტალაციის დირექტორიასთან შედარებით.

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

მოდით დავადგინოთ ენის სტანდარტი. რა თქმა უნდა, ბოლო. ამავდროულად, ჩვენ არა მხოლოდ ვაერთიანებთ სტანდარტს, არამედ ვავრცელებთ მას, ვინც ისარგებლებს ჩვენი ბიბლიოთეკით. ეს მიიღწევა იმის გამო, რომ კომპლექტს აქვს კატეგორია INTERFACE (იხილეთ target_compile_features ბრძანება).

target_compile_features(mylib INTERFACE cxx_std_17)

მოდით შევქმნათ მეტსახელი ჩვენი ბიბლიოთეკისთვის. უფრო მეტიც, სილამაზისთვის ის სპეციალურ "სახელთა სივრცეში" იქნება. ეს გამოგადგებათ, როცა ჩვენს ბიბლიოთეკაში გამოჩნდება სხვადასხვა მოდული და ჩვენ მათ ერთმანეთისგან დამოუკიდებლად ვაკავშირებთ. როგორც მაგალითად, ბუსტაში.

add_library(Mylib::mylib ALIAS mylib)

დაყენების

ჩვენი სათაურების დაყენება სისტემაში. აქ ყველაფერი მარტივია. ჩვენ ვამბობთ, რომ საქაღალდე ყველა სათაურით უნდა შევიდეს დირექტორიაში include ინსტალაციის ადგილთან შედარებით.

install(DIRECTORY include/mylib DESTINATION include)

შემდეგი, ჩვენ ვაცნობებთ build სისტემას, რომ გვსურს ბრძანების გამოძახება მესამე მხარის პროექტებში find_package(Mylib) და მიიღეთ მიზანი Mylib::mylib.

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

შემდეგი შელოცვა ასე უნდა გავიგოთ. როდესაც მესამე მხარის პროექტში ჩვენ ვუწოდებთ ბრძანებას find_package(Mylib 1.2.3 REQUIRED)და დაინსტალირებული ბიბლიოთეკის რეალური ვერსია შეუთავსებელი იქნება ვერსიასთან 1.2.3CMake ავტომატურად წარმოქმნის შეცდომას. ანუ, თქვენ არ დაგჭირდებათ ვერსიების ხელით თვალყურის დევნება.

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)

ტესტები

თუ ტესტები გამორთულია აშკარად გამოყენებით შესაბამისი ვარიანტი ან ჩვენი პროექტი არის ქვეპროექტი, ანუ ის დაკავშირებულია სხვა CMake პროექტთან ბრძანების გამოყენებით add_subdirectory, ჩვენ არ მივდივართ იერარქიის გასწვრივ და სკრიპტი, რომელიც აღწერს ტესტების გენერირებისა და გაშვების ბრძანებებს, უბრალოდ არ მუშაობს.

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

დოკუმენტაცია

ასევე არ შეიქმნება დოკუმენტაცია ქვეპროექტის შემთხვევაში.

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

ონლაინ ქვიშის ყუთი

ანალოგიურად, ქვეპროექტს არ ექნება ონლაინ ქვიშის ყუთი.

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

ტესტის სკრიპტი (test/CMakeLists.txt)

ტესტირება

უპირველეს ყოვლისა, ჩვენ ვპოულობთ პაკეტს საჭირო ტესტის ჩარჩოთი (შეცვალეთ თქვენი საყვარელით).

find_package(doctest 2.3.3 REQUIRED)

მოდით შევქმნათ ჩვენი შესრულებადი ფაილი ტესტებით. როგორც წესი, მე ვამატებ პირდაპირ შესრულებად ბინარს მხოლოდ იმ ფაილს, რომელიც შეიცავს ფუნქციას main.

add_executable(mylib-unit-tests test_main.cpp)

მე დავამატებ ფაილებს, რომლებშიც თავად ტესტები მოგვიანებით არის აღწერილი. მაგრამ თქვენ არ გჭირდებათ ამის გაკეთება.

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

ჩვენ ვაკავშირებთ დამოკიდებულებებს. გთხოვთ გაითვალისწინოთ, რომ ჩვენ მხოლოდ CMake სამიზნეები დავუკავშირეთ ჩვენს ბინარს და არ გამოვიძახეთ ბრძანება target_include_directories. სათაურები ტესტის ჩარჩოდან და ჩვენიდან Mylib::mylib, ისევე როგორც build-ის პარამეტრები (ჩვენს შემთხვევაში, ეს არის C++ ენის სტანდარტი) ამ მიზნებთან ერთად.

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

დაბოლოს, ჩვენ ვქმნით მატყუარა სამიზნეს, რომლის „build“ უდრის გაშვებულ ტესტებს და ამ სამიზნეს ვამატებთ ნაგულისხმევ build-ს (ატრიბუტი პასუხისმგებელია ამაზე ALL). ეს ნიშნავს, რომ ნაგულისხმევი build იწვევს ტესტების გაშვებას, რაც იმას ნიშნავს, რომ ჩვენ არასოდეს დავივიწყებთ მათ გაშვებას.

add_custom_target(check ALL COMMAND mylib-unit-tests)

დაფარვის

შემდეგი, ჩვენ ჩართავთ კოდის დაფარვის გაზომვას, თუ მითითებულია შესაბამისი ვარიანტი. დეტალებში არ შევალ, რადგან ისინი უფრო მეტად ეხება დაფარვის საზომ ინსტრუმენტს, ვიდრე CMake-ს. მხოლოდ მნიშვნელოვანია აღინიშნოს, რომ შედეგების საფუძველზე შეიქმნება მიზანი coverage, რომლითაც მოსახერხებელია დაფარვის გაზომვის დაწყება.

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

სკრიპტი დოკუმენტაციისთვის (doc/CMakeLists.txt)

ნაპოვნია დოქსიგენი.

find_package(Doxygen)

შემდეგი, ჩვენ ვამოწმებთ, დააყენა თუ არა მომხმარებელმა ენის ცვლადი. თუ კი, მაშინ არ შევეხებით, თუ არა, მაშინ რუსულად ვიღებთ. შემდეგ ჩვენ ვაკონფიგურირებთ Doxygen სისტემის ფაილებს. ყველა საჭირო ცვლადი, მათ შორის ენა, მიდის იქ კონფიგურაციის პროცესში (იხ. команду configure_file).

შემდეგ ჩვენ ვქმნით მიზანს doc, რომელიც დაიწყებს დოკუმენტაციის გენერირებას. ვინაიდან დოკუმენტაციის გენერირება არ არის ყველაზე დიდი საჭიროება განვითარების პროცესში, სამიზნე არ იქნება ჩართული ნაგულისხმევად; ის პირდაპირ უნდა იყოს გაშვებული.

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

სკრიპტი ონლაინ sandbox-ისთვის (online/CMakeLists.txt)

აქ ვპოულობთ მესამე პითონს და ვქმნით სამიზნეს wandbox, რომელიც ქმნის სერვისის API-ს შესაბამის მოთხოვნას კვერთხიდა აგზავნის მას. პასუხი მოყვება მზა ქვიშის ყუთის ბმულს.

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

პროექტი გარეთ

ახლა ვნახოთ, როგორ გამოვიყენოთ ეს ყველაფერი.

ასამბლეა

ამ პროექტის მშენებლობა, ისევე როგორც ნებისმიერი სხვა პროექტი CMake build სისტემაზე, შედგება ორი ეტაპისგან:

თაობა

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

თუ ზემოთ მოცემული ბრძანება არ მუშაობდა CMake-ის ძველი ვერსიის გამო, სცადეთ გამოტოვება -S:
cmake путь/к/исходникам -B путь/к/сборочной/директории [опции ...]

მეტი ვარიანტების შესახებ.

პროექტის აშენება

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

მეტი შეკრების მიზნების შესახებ.

პარამეტრები

MYLIB_COVERAGE

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

მოიცავს სამიზნეს coverage, რომლითაც შეგიძლიათ დაიწყოთ კოდის დაფარვის გაზომვა ტესტებით.

MYLIB_TESTING

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

უზრუნველყოფს ერთეულის ტესტის აგებისა და მიზნის გამორთვის შესაძლებლობას check. შედეგად, ტესტებით კოდის დაფარვის გაზომვა გამორთულია (იხ. MYLIB_COVERAGE).

ტესტირება ასევე ავტომატურად გამორთულია, თუ პროექტი დაკავშირებულია სხვა პროექტთან, როგორც ქვეპროექტი ბრძანების გამოყენებით add_subdirectory.

MYLIB_DOXYGEN_LANGUAGE

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

ცვლის დოკუმენტაციის ენას, რომელსაც სამიზნე ქმნის doc მოცემულს. ხელმისაწვდომი ენების ჩამონათვალისთვის იხ Doxygen სისტემის ვებსაიტი.

რუსული ჩართულია ნაგულისხმევად.

ასამბლეის მიზნები

სტანდარტულად

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

თუ სამიზნე არ არის მითითებული (რაც სამიზნის ექვივალენტია all), აგროვებს ყველაფერს, რაც შეუძლია და ასევე რეკავს სამიზნეს check.

mylib-unit-tests

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

ადგენს ერთეულ ტესტებს. ნაგულისხმევად ჩართულია.

შემოწმება

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

აწარმოებს შეგროვებულ (შეგროვებულ, თუ უკვე არა) ერთეულ ტესტებს. ნაგულისხმევად ჩართულია.

См. также mylib-unit-tests.

დაფარვის

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

აანალიზებს გაშვებულ (აწარმოებს, თუ უკვე არა) ერთეულების ტესტებს კოდის დაფარვისთვის პროგრამის გამოყენებით ტესტებით gcovr.

საფარის გამონაბოლქვი ასე გამოიყურება:

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

სამიზნე ხელმისაწვდომია მხოლოდ მაშინ, როდესაც ეს ვარიანტი ჩართულია MYLIB_COVERAGE.

См. также check.

doc

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

იწყებს კოდის დოკუმენტაციის გენერირებას სისტემის გამოყენებით ჟანგბადი.

კვერთხის ყუთი

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

სამსახურის პასუხი ასე გამოიყურება:

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

ამისთვის გამოიყენება სერვისი კვერთხი. არ ვიცი რამდენად მოქნილია მათი სერვერები, მაგრამ ვფიქრობ, რომ ეს შესაძლებლობა არ უნდა იქნას ბოროტად გამოყენებული.

მაგალითები

შექმენით პროექტი გამართვის რეჟიმში დაფარვის გაზომვით

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

პროექტის ინსტალაცია წინასწარი შეკრებისა და ტესტირების გარეშე

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

შექმენით გამოშვების რეჟიმში მოცემული შემდგენელით

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

დოკუმენტაციის გენერირება ინგლისურ ენაზე

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

ინსტრუმენტები

Cmake 3.13

სინამდვილეში, CMake ვერსია 3.13 საჭიროა მხოლოდ ამ დახმარებაში აღწერილი კონსოლის ზოგიერთი ბრძანების გასაშვებად. CMake სკრიპტების სინტაქსის თვალსაზრისით, 3.8 ვერსია საკმარისია, თუ გენერაცია სხვა გზით არის გამოძახებული.
ტესტირების ბიბლიოთეკა დოქტესტი

ტესტირება შეიძლება გამორთოთ (იხ опцию MYLIB_TESTING).
ჟანგბადი

ენის შესაცვლელად, რომელზედაც შეიქმნება დოკუმენტაცია, გათვალისწინებულია ვარიანტი MYLIB_DOXYGEN_LANGUAGE.
ენის თარჯიმანი Python 3

ავტომატური წარმოებისთვის ონლაინ ქვიშის ყუთები.

სტატიკური ანალიზი

CMake-ით და რამდენიმე კარგი ხელსაწყოთი, შეგიძლიათ უზრუნველყოთ სტატიკური ანალიზი მინიმალური ძალისხმევით.

Cppcheck

CMake-ს აქვს სტატიკური ანალიზის ხელსაწყოს ჩაშენებული მხარდაჭერა Cppcheck.

ამისათვის თქვენ უნდა გამოიყენოთ ვარიანტი CMAKE_CXX_CPPCHECK:

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

ამის შემდეგ, სტატიკური ანალიზი ავტომატურად ამოქმედდება ყოველ ჯერზე, როცა წყაროს შედგენა და ხელახლა კომპილაცია მოხდება. დამატებითი არაფრის გაკეთება არ არის საჭირო.

ჟღალი

მშვენიერი ხელსაწყოს დახმარებით scan-build თქვენ ასევე შეგიძლიათ აწარმოოთ სტატიკური ანალიზი უმოკლეს დროში:

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

აქ, Cppcheck-ის შემთხვევისგან განსხვავებით, თქვენ უნდა გაუშვათ build ყოველ ჯერზე scan-build.

Afterword

CMake არის ძალიან ძლიერი და მოქნილი სისტემა, რომელიც საშუალებას გაძლევთ განახორციელოთ ფუნქციები ყველა გემოვნებისა და ფერისთვის. და, მიუხედავად იმისა, რომ სინტაქსი ზოგჯერ სასურველს ტოვებს, ეშმაკი მაინც არ არის ისეთი საშინელი, როგორც მას ხატავენ. გამოიყენეთ CMake build სისტემა საზოგადოებისა და ჯანმრთელობის საკეთილდღეოდ.

→ ჩამოტვირთეთ პროექტის შაბლონი

წყარო: www.habr.com

CMake და C++ სამუდამოდ ძმები არიან