🥇CMake ഉം C++ ഉം എന്നും സഹോദരങ്ങളാണ്

വികസന സമയത്ത്, കംപൈലറുകൾ മാറ്റാനും മോഡുകൾ നിർമ്മിക്കാനും ഡിപൻഡൻസി പതിപ്പുകൾ നടത്താനും സ്റ്റാറ്റിക് വിശകലനം നടത്താനും പ്രകടനം അളക്കാനും കവറേജ് ശേഖരിക്കാനും ഡോക്യുമെന്റേഷൻ സൃഷ്ടിക്കാനും ഞാൻ ആഗ്രഹിക്കുന്നു. ഞാൻ CMake ശരിക്കും ഇഷ്ടപ്പെടുന്നു, കാരണം എനിക്ക് ആവശ്യമുള്ളതെല്ലാം ചെയ്യാൻ ഇത് എന്നെ അനുവദിക്കുന്നു.

പലരും CMake വിമർശിക്കുന്നു, പലപ്പോഴും അത് അർഹിക്കുന്നു, എന്നാൽ നിങ്ങൾ അത് നോക്കുകയാണെങ്കിൽ, എല്ലാം അത്ര മോശമല്ല, അടുത്തിടെ ഒട്ടും മോഷമല്ല, и направление развития вполне позитивное.

ഈ കുറിപ്പിൽ, CMake സിസ്റ്റത്തിൽ C++ ൽ ഒരു ഹെഡർ ലൈബ്രറി എങ്ങനെ ലളിതമായി ഓർഗനൈസുചെയ്യാമെന്ന് ഞാൻ നിങ്ങളോട് പറയാൻ ആഗ്രഹിക്കുന്നു:

അസംബ്ലി;
ഓട്ടോറൺ ടെസ്റ്റുകൾ;
കോഡ് കവറേജ് അളക്കൽ;
ഇൻസ്റ്റലേഷൻ;
Автодокументирование;
Генерацию онлайн-песочницы;
സ്റ്റാറ്റിക് വിശകലനം.

നേട്ടങ്ങളും സി-മേക്കുകളും ഇതിനകം മനസ്സിലാക്കുന്ന ആർക്കും ലളിതമായി ചെയ്യാം скачать шаблон проекта അത് ഉപയോഗിക്കാൻ തുടങ്ങുക.

Проект изнутри

പദ്ധതിയുടെ ഘടന

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

അടുത്തതായി, മൂന്നാം കക്ഷി പ്രോജക്റ്റുകളിൽ കമാൻഡിലേക്ക് വിളിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് ഞങ്ങൾ ബിൽഡ് സിസ്റ്റത്തെ അറിയിക്കുന്നു 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
)

അവസാനമായി, ഞങ്ങൾ ഒരു ഡമ്മി ടാർഗെറ്റ് സൃഷ്ടിക്കുന്നു, അതിന്റെ "ബിൽഡ്" റണ്ണിംഗ് ടെസ്റ്റുകൾക്ക് തുല്യമാണ്, കൂടാതെ ഈ ടാർഗെറ്റ് ഡിഫോൾട്ട് ബിൽഡിലേക്ക് ചേർക്കുകയും (ആട്രിബ്യൂട്ട് ഇതിന് ഉത്തരവാദിയാണ്. 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)

ഡോക്‌സിജൻ കണ്ടെത്തി.

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

ഇവിടെ നമ്മൾ മൂന്നാമത്തെ പൈത്തണിനെ കണ്ടെത്തി ഒരു ലക്ഷ്യം സൃഷ്ടിക്കുന്നു 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 തന്നിരിക്കുന്നവനോട്. ലഭ്യമായ ഭാഷകളുടെ ഒരു ലിസ്റ്റിനായി, കാണുക ഡോക്സിജൻ സിസ്റ്റം വെബ്സൈറ്റ്.

По умолчанию включён русский.

അസംബ്ലി ലക്ഷ്യങ്ങൾ

സ്ഥിരമായി

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

ലക്ഷ്യം വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ (ഇത് ലക്ഷ്യത്തിന് തുല്യമാണ് all), അതിന് കഴിയുന്നതെല്ലാം ശേഖരിക്കുന്നു, കൂടാതെ ലക്ഷ്യത്തെ വിളിക്കുകയും ചെയ്യുന്നു check.

mylib-unit-ടെസ്റ്റുകൾ

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

സിസ്റ്റം ഉപയോഗിച്ച് കോഡ് ഡോക്യുമെന്റേഷന്റെ ജനറേഷൻ ആരംഭിക്കുന്നു ഡോക്സിജൻ.

wandbox

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.
ഭാഷാ വ്യാഖ്യാതാവ് പൈത്തൺ 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++ ഉം എന്നേക്കും സഹോദരങ്ങളാണ്