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

ಆನ್‌ಲೈನ್ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ಗಾಗಿ ಸ್ಕ್ರಿಪ್ಟ್ (ಆನ್‌ಲೈನ್/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.

ಮೈಲಿಬ್-ಘಟಕ-ಪರೀಕ್ಷೆಗಳು

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.

ನಂತರದ

CMake ಅತ್ಯಂತ ಶಕ್ತಿಯುತ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ವ್ಯವಸ್ಥೆಯಾಗಿದ್ದು ಅದು ಪ್ರತಿ ರುಚಿ ಮತ್ತು ಬಣ್ಣಕ್ಕೆ ಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಮತ್ತು, ಸಿಂಟ್ಯಾಕ್ಸ್ ಕೆಲವೊಮ್ಮೆ ಅಪೇಕ್ಷಿತವಾಗಿರುವುದನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆಯಾದರೂ, ದೆವ್ವವು ಇನ್ನೂ ಚಿತ್ರಿಸಿದಷ್ಟು ಭಯಾನಕವಲ್ಲ. ಸಮಾಜ ಮತ್ತು ಆರೋಗ್ಯದ ಪ್ರಯೋಜನಕ್ಕಾಗಿ CMake ಬಿಲ್ಡ್ ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸಿ.

→ ಯೋಜನೆಯ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ

ಮೂಲ: www.habr.com

CMake ಮತ್ತು C++ ಎಂದೆಂದಿಗೂ ಸಹೋದರರು