🥇CMake ਅਤੇ C++ ਹਮੇਸ਼ਾ ਲਈ ਭਰਾ ਹਨ

ਵਿਕਾਸ ਦੇ ਦੌਰਾਨ, ਮੈਂ ਕੰਪਾਈਲਰ ਨੂੰ ਬਦਲਣਾ, ਮੋਡ ਬਣਾਉਣਾ, ਨਿਰਭਰਤਾ ਸੰਸਕਰਣ ਕਰਨਾ, ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨਾ, ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਮਾਪਣਾ, ਕਵਰੇਜ ਇਕੱਠਾ ਕਰਨਾ, ਦਸਤਾਵੇਜ਼ ਤਿਆਰ ਕਰਨਾ, ਆਦਿ ਕਰਨਾ ਪਸੰਦ ਕਰਦਾ ਹਾਂ। ਅਤੇ ਮੈਂ ਸੱਚਮੁੱਚ ਸੀਮੇਕ ਨੂੰ ਪਿਆਰ ਕਰਦਾ ਹਾਂ ਕਿਉਂਕਿ ਇਹ ਮੈਨੂੰ ਉਹ ਸਭ ਕੁਝ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜੋ ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ.

ਬਹੁਤ ਸਾਰੇ ਲੋਕ ਸੀਮੇਕ ਦੀ ਆਲੋਚਨਾ ਕਰਦੇ ਹਨ, ਅਤੇ ਅਕਸਰ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਹੱਕਦਾਰ ਹੁੰਦੇ ਹਨ, ਪਰ ਜੇ ਤੁਸੀਂ ਇਸ ਨੂੰ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਸਭ ਕੁਝ ਇੰਨਾ ਬੁਰਾ ਨਹੀਂ ਹੈ, ਅਤੇ ਹਾਲ ਹੀ ਵਿੱਚ ਬਿਲਕੁਲ ਵੀ ਬੁਰਾ ਨਹੀਂ, ਅਤੇ ਵਿਕਾਸ ਦੀ ਦਿਸ਼ਾ ਕਾਫ਼ੀ ਸਕਾਰਾਤਮਕ ਹੈ.

ਇਸ ਨੋਟ ਵਿੱਚ, ਮੈਂ ਤੁਹਾਨੂੰ ਇਹ ਦੱਸਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਹੇਠਾਂ ਦਿੱਤੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਸੀਮੇਕ ਸਿਸਟਮ ਵਿੱਚ 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 ਫਾਈਲ (./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)

ਅਸੀਂ ਸਿਰਲੇਖਾਂ ਨੂੰ ਸਾਡੀ ਇੰਟਰਫੇਸ ਲਾਇਬ੍ਰੇਰੀ ਨਾਲ ਬੰਨ੍ਹਦੇ ਹਾਂ।

ਸੀਮੇਕ ਦੀ ਆਧੁਨਿਕ, ਫੈਸ਼ਨੇਬਲ, ਨੌਜਵਾਨਾਂ ਦੀ ਵਰਤੋਂ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਿਰਲੇਖ, ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ, ਆਦਿ। ਇੱਕ ਸਿੰਗਲ ਟੀਚੇ ਦੁਆਰਾ ਪ੍ਰਸਾਰਿਤ. ਇਸ ਲਈ ਇਹ ਕਹਿਣਾ ਕਾਫੀ ਹੈ 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)

ਅਸੀਂ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਜੋੜਦੇ ਹਾਂ। ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਉ ਕਿ ਅਸੀਂ ਸਿਰਫ਼ ਉਹਨਾਂ ਸੀਮੇਕ ਟੀਚਿਆਂ ਨੂੰ ਆਪਣੀ ਬਾਈਨਰੀ ਨਾਲ ਜੋੜਿਆ ਹੈ ਜਿਨ੍ਹਾਂ ਦੀ ਸਾਨੂੰ ਲੋੜ ਹੈ ਅਤੇ ਕਮਾਂਡ ਨੂੰ ਕਾਲ ਨਹੀਂ ਕੀਤਾ 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)

ਕੋਟਿੰਗ

ਅੱਗੇ, ਜੇਕਰ ਢੁਕਵਾਂ ਵਿਕਲਪ ਦਿੱਤਾ ਗਿਆ ਹੈ ਤਾਂ ਅਸੀਂ ਕੋਡ ਕਵਰੇਜ ਮਾਪ ਨੂੰ ਸਮਰੱਥ ਕਰਦੇ ਹਾਂ। ਮੈਂ ਵੇਰਵਿਆਂ ਵਿੱਚ ਨਹੀਂ ਜਾਵਾਂਗਾ, ਕਿਉਂਕਿ ਉਹ ਸੀਮੇਕ ਦੀ ਬਜਾਏ ਕਵਰੇਜ ਨੂੰ ਮਾਪਣ ਲਈ ਇੱਕ ਸਾਧਨ ਨਾਲ ਵਧੇਰੇ ਸਬੰਧਤ ਹਨ. ਇਹ ਸਿਰਫ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਨਤੀਜਿਆਂ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਟੀਚਾ ਬਣਾਇਆ ਜਾਵੇਗਾ 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 -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-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

ਸੰਦ

ਮੁੱਖ ਮੰਤਰੀ 3.13

ਵਾਸਤਵ ਵਿੱਚ, CMake ਸੰਸਕਰਣ 3.13 ਨੂੰ ਸਿਰਫ ਇਸ ਮਦਦ ਵਿੱਚ ਵਰਣਿਤ ਕੁਝ ਕੰਸੋਲ ਕਮਾਂਡਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਲੋੜੀਂਦਾ ਹੈ। CMake ਸਕ੍ਰਿਪਟਾਂ ਦੇ ਸੰਟੈਕਸ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਸੰਸਕਰਣ 3.8 ਕਾਫ਼ੀ ਹੈ ਜੇਕਰ ਪੀੜ੍ਹੀ ਨੂੰ ਹੋਰ ਤਰੀਕਿਆਂ ਨਾਲ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ।
ਟੈਸਟਿੰਗ ਲਾਇਬ੍ਰੇਰੀ doctest

ਟੈਸਟਿੰਗ ਨੂੰ ਅਯੋਗ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਵੇਖੋ опцию MYLIB_TESTING).
ਆਕਸੀਜਨ

ਉਸ ਭਾਸ਼ਾ ਨੂੰ ਬਦਲਣ ਲਈ ਜਿਸ ਵਿੱਚ ਦਸਤਾਵੇਜ਼ ਤਿਆਰ ਕੀਤੇ ਜਾਣਗੇ, ਇੱਕ ਵਿਕਲਪ ਦਿੱਤਾ ਗਿਆ ਹੈ MYLIB_DOXYGEN_LANGUAGE.
ਭਾਸ਼ਾ ਅਨੁਵਾਦਕ ਪਾਇਥਨ 3

ਆਟੋਮੈਟਿਕ ਪੀੜ੍ਹੀ ਲਈ ਆਨਲਾਈਨ ਸੈਂਡਬਾਕਸ.

ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਣ

CMake ਅਤੇ ਕੁਝ ਚੰਗੇ ਸਾਧਨਾਂ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਘੱਟੋ-ਘੱਟ ਕੋਸ਼ਿਸ਼ ਨਾਲ ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਣ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹੋ।

ਸੀਪੀਪੀਚੈਕ

CMake ਕੋਲ ਇੱਕ ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਣ ਟੂਲ ਲਈ ਬਿਲਟ-ਇਨ ਸਮਰਥਨ ਹੈ ਸੀਪੀਪੀਚੈਕ.

ਅਜਿਹਾ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਵਿਕਲਪ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ 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 ਇੱਕ ਬਹੁਤ ਸ਼ਕਤੀਸ਼ਾਲੀ ਅਤੇ ਲਚਕਦਾਰ ਸਿਸਟਮ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਹਰ ਸਵਾਦ ਅਤੇ ਰੰਗ ਲਈ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਅਤੇ, ਹਾਲਾਂਕਿ ਸੰਟੈਕਸ ਕਈ ਵਾਰ ਲੋੜੀਂਦੇ ਹੋਣ ਲਈ ਬਹੁਤ ਕੁਝ ਛੱਡ ਦਿੰਦਾ ਹੈ, ਸ਼ੈਤਾਨ ਅਜੇ ਵੀ ਓਨਾ ਭਿਆਨਕ ਨਹੀਂ ਹੈ ਜਿੰਨਾ ਉਸਨੂੰ ਪੇਂਟ ਕੀਤਾ ਗਿਆ ਹੈ. ਸਮਾਜ ਅਤੇ ਸਿਹਤ ਦੇ ਫਾਇਦੇ ਲਈ ਸੀਮੇਕ ਬਿਲਡ ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਕਰੋ।

→ ਪ੍ਰੋਜੈਕਟ ਟੈਮਪਲੇਟ ਡਾਊਨਲੋਡ ਕਰੋ

ਸਰੋਤ: www.habr.com

CMake ਅਤੇ C++ ਹਮੇਸ਼ਾ ਲਈ ਭਰਾ ਹਨ