🥇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 (Cm. 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

సాధన

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.

తరువాతి మాట

CMake అనేది చాలా శక్తివంతమైన మరియు సౌకర్యవంతమైన వ్యవస్థ, ఇది ప్రతి రుచి మరియు రంగు కోసం కార్యాచరణను అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. మరియు, వాక్యనిర్మాణం కొన్నిసార్లు చాలా కోరుకున్నప్పటికీ, దెయ్యం ఇప్పటికీ అతను చిత్రించినంత భయంకరమైనది కాదు. సమాజం మరియు ఆరోగ్యం కోసం CMake బిల్డ్ సిస్టమ్‌ను ఉపయోగించండి.

→ ప్రాజెక్ట్ టెంప్లేట్‌ను డౌన్‌లోడ్ చేయండి

మూలం: www.habr.com

CMake మరియు C++ ఎప్పటికీ సోదరులు