🥇CMake និង C++ ជាបងប្អូននឹងគ្នាជារៀងរហូត

កំឡុងពេលអភិវឌ្ឍន៍ ខ្ញុំចូលចិត្តផ្លាស់ប្តូរកម្មវិធីចងក្រង របៀបបង្កើត កំណែអាស្រ័យ ធ្វើការវិភាគឋិតិវន្ត វាស់វែងការអនុវត្ត ប្រមូលការគ្របដណ្តប់ បង្កើតឯកសារជាដើម។ ហើយខ្ញុំពិតជាស្រឡាញ់ CMake ព្រោះវាអនុញ្ញាតឱ្យខ្ញុំធ្វើអ្វីគ្រប់យ៉ាងដែលខ្ញុំចង់បាន។

មនុស្សជាច្រើនរិះគន់ CMake ហើយជារឿយៗសមនឹងទទួលបាន ប៉ុន្តែប្រសិនបើអ្នកក្រឡេកមើលវាមិនមែនសុទ្ធតែអាក្រក់នោះទេ ហើយថ្មីៗនេះ មិនអាក្រក់ទាល់តែសោះហើយទិសដៅនៃការអភិវឌ្ឍន៍គឺមានភាពវិជ្ជមាន។

នៅក្នុងកំណត់ចំណាំនេះ ខ្ញុំចង់ប្រាប់អ្នកពីរបៀបរៀបចំបណ្ណាល័យបឋមកថានៅក្នុង C++ នៅក្នុងប្រព័ន្ធ CMake ដើម្បីទទួលបានមុខងារដូចខាងក្រោម៖

សន្និបាត;
ការធ្វើតេស្តស្វ័យប្រវត្តិ;
ការវាស់វែងគ្របដណ្តប់លេខកូដ;
ការដំឡើង;
ឯកសារស្វ័យប្រវត្តិ;
ការបង្កើតប្រអប់ខ្សាច់លើបណ្តាញ;
ការវិភាគឋិតិវន្ត។

អ្នកណាដែលយល់ពីគុណសម្បត្តិរួចហើយ 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)

តោះបង្កើតឈ្មោះក្លែងក្លាយសម្រាប់បណ្ណាល័យរបស់យើង។ លើសពីនេះទៅទៀតសម្រាប់ភាពស្រស់ស្អាតវានឹងស្ថិតនៅក្នុង "ឈ្មោះ" ពិសេស។ វានឹងមានប្រយោជន៍នៅពេលដែលម៉ូឌុលផ្សេងគ្នាលេចឡើងនៅក្នុងបណ្ណាល័យរបស់យើង ហើយយើងចូលទៅភ្ជាប់ពួកវាដោយឯករាជ្យពីគ្នាទៅវិញទៅមក។ ឧទាហរណ៍ដូចជា Busta.

add_library(Mylib::mylib ALIAS mylib)

ការកំណត់

ការដំឡើងបឋមកថារបស់យើងទៅក្នុងប្រព័ន្ធ។ អ្វីគ្រប់យ៉ាងគឺសាមញ្ញនៅទីនេះ។ យើងនិយាយថាថតដែលមានបឋមកថាទាំងអស់គួរតែចូលទៅក្នុងថត include ទាក់ទងទៅនឹងទីតាំងដំឡើង។

install(DIRECTORY include/mylib DESTINATION include)

បន្ទាប់មក យើងជូនដំណឹងដល់ប្រព័ន្ធស្ថាបនាថា យើងចង់អាចហៅពាក្យបញ្ជានៅក្នុងគម្រោងភាគីទីបី 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ក៏ដូចជាប៉ារ៉ាម៉ែត្រស្ថាបនា (ក្នុងករណីរបស់យើងនេះគឺជាស្តង់ដារភាសា C ++) បានឆ្លងកាត់ជាមួយនឹងគោលដៅទាំងនេះ។

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

ជាចុងក្រោយ យើងបង្កើតគោលដៅអត់ចេះសោះ “Build” ដែលស្មើនឹងការសាកល្បងដែលកំពុងដំណើរការ ហើយបន្ថែមគោលដៅនេះទៅក្នុង default build (គុណលក្ខណៈគឺទទួលខុសត្រូវចំពោះបញ្ហានេះ។ ALL) នេះមានន័យថាការបង្កើតលំនាំដើមធ្វើឱ្យការធ្វើតេស្តដំណើរការ មានន័យថាយើងនឹងមិនភ្លេចដំណើរការពួកវាឡើយ។

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)

បានរកឃើញ Doxygen.

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

ស្គ្រីបសម្រាប់ប្រអប់ខ្សាច់អនឡាញ (online/CMakeLists.txt)

នៅទីនេះយើងរកឃើញ Python ទីបីហើយបង្កើតគោលដៅ 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 មានពីរដំណាក់កាល៖

ជំនាន់

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.

ឯកសារ

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

ឧបករណ៍

ស៊ីម៉ាក់ 3.13

តាមពិត CMake កំណែ 3.13 គឺតម្រូវឱ្យដំណើរការតែកុងសូលពាក្យបញ្ជាមួយចំនួនដែលបានពិពណ៌នានៅក្នុងជំនួយនេះ។ តាមទស្សនៈនៃវាក្យសម្ព័ន្ធនៃស្គ្រីប CMake កំណែ 3.8 គឺគ្រប់គ្រាន់ប្រសិនបើជំនាន់ត្រូវបានហៅតាមវិធីផ្សេងទៀត។
បណ្ណាល័យសាកល្បង វេជ្ជបណ្ឌិត

ការធ្វើតេស្តអាចត្រូវបានបិទ (សូមមើល опцию MYLIB_TESTING).
ដូយហ្គីន

ដើម្បីប្តូរភាសាដែលឯកសារនឹងត្រូវបានបង្កើត ជម្រើសមួយត្រូវបានផ្តល់ជូន MYLIB_DOXYGEN_LANGUAGE.
អ្នកបកប្រែភាសា ពស់ថ្លាន់ 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 ទេ អ្នកត្រូវដំណើរការការស្ថាបនារាល់ពេលឆ្លងកាត់ scan-build.

Afterword

CMake គឺជាប្រព័ន្ធដ៏មានឥទ្ធិពល និងអាចបត់បែនបាន ដែលអនុញ្ញាតឱ្យអ្នកអនុវត្តមុខងារសម្រាប់គ្រប់រសជាតិ និងពណ៌។ ហើយទោះបីជាវាក្យសម្ព័ន្ធពេលខ្លះទុកអោយមានការចង់បានក៏ដោយ ក៏អារក្សនៅតែមិនគួរឱ្យខ្លាចដូចដែលវាត្រូវបានលាបពណ៌។ ប្រើប្រាស់ប្រព័ន្ធសាងសង់ CMake ដើម្បីជាប្រយោជន៍ដល់សង្គម និងសុខភាព។

→ ទាញយកគំរូគម្រោង

ប្រភព: www.habr.com

CMake និង C++ គឺជាបងប្អូននឹងគ្នាជារៀងរហូត