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

สุดท้ายนี้ เราสร้างเป้าหมายจำลอง "บิลด์" ซึ่งเทียบเท่ากับการทดสอบที่กำลังรันอยู่ และเพิ่มเป้าหมายนี้ให้กับบิลด์เริ่มต้น (แอตทริบิวต์จะรับผิดชอบในสิ่งนี้ 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)

ต่อไปเราจะตรวจสอบว่าผู้ใช้ได้ตั้งค่าตัวแปรภาษาหรือไม่ ถ้าใช่เราก็อย่าแตะมันถ้าไม่ใช่เราก็เอาภาษารัสเซีย จากนั้นเรากำหนดค่าไฟล์ระบบ 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

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

สร้างในโหมด release ด้วยคอมไพเลอร์ที่กำหนด

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 และเครื่องมือดีๆ สองสามอย่าง คุณสามารถวิเคราะห์แบบคงที่ได้โดยใช้ความพยายามเพียงเล็กน้อย

ซีพีเช็ค

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 เป็นระบบที่ทรงพลังและยืดหยุ่นมากซึ่งช่วยให้คุณใช้ฟังก์ชันการทำงานสำหรับทุกรสนิยมและทุกสี และแม้ว่าบางครั้งไวยากรณ์จะออกมาเป็นที่ต้องการมาก แต่มารก็ยังไม่น่ากลัวเท่ากับที่เขาวาด ใช้ระบบสร้าง CMake เพื่อประโยชน์ของสังคมและสุขภาพ

→ ดาวน์โหลดเทมเพลตโครงการ

ที่มา: will.com

CMake และ C++ เป็นพี่น้องกันตลอดไป