Записки программиста
Некоторое время назад мы познакомились с Autotools. Несмотря на то, что Autotools до сих пор используется во многих известных проектах с открытым исходным кодом, инструмент этот трудно назвать особо удобным. Кроме того, нормально работает он только в *nix системах, а в каком-нибудь Windows пользоваться Autotools, скажем так, весьма непросто. В общем, Autotools — это легаси, и нормальные программисты в наше время пытаются использовать CMake или, например, SCons. В этой заметке мы познакомимся с CMake.
Говоря простыми словами, CMake — это такая штука, в которой вы описываете проект, а она вам генерирует Makefile’ы в *nix системах, проекты Visual Studio под Windows, файлы конкретных редакторов и IDE, например Sublime Text, Code::Blocks, Eclipse или KDevelop, и так далее. Несмотря на спорный в некоторых моментах синтаксис, в последнее время CMake становится стандартом де-факто в мире C/C++. В частности, CMake используется в LLVM, Qt, MariaDB, Blender, KiCad, GNU Radio и ряде других проектов. Кроме того, в CLion, IDE для C/C++ от компании JetBrains, по умолчанию также создаются проекты, основанные на CMake.
Использование CMake в простейшем случае выглядит следующим образом. В корне репозитория создается файл CMakeLists.txt примерно такого содержания:
cmake_minimum_required ( VERSION 3.1 )
# так пишутся комментарии
find_library ( PTHREAD_LIBRARY pthread )
find_library ( PCRE_LIBRARY pcre )
include_directories ( include )
set ( CMAKE_CXX_STANDARD 17 )
set ( CMAKE_CXX_STANDARD_REQUIRED on )
set ( CMAKE_CXX_FLAGS » $ -Wall -Wextra -Werror» )
add_executable ( main src/Main.cpp src/HttpServer.cpp )
Хочется надеяться, какая строчка здесь что означает, пояснять не нужно. Затем исходники складываются в каталог src, а заголовочные файлы — в каталог include. Для сборки проекта говорим:
mkdir build
cd build
cmake ..
make
Просто, не правда ли?
Помимо приведенного выше find_library в CMake есть ряд скриптов для подключения конкретных библиотек. В частности, подключение OpenGL осуществляется как-то так:
find_package ( OpenGL REQUIRED )
CMake можно указать конкретный тип Makefile’ов, которые вы хотите получить на выходе:
cmake -G «Unix Makefiles» ..
cmake -G «MinGW Makefiles» ..
# для просмотра списка всех доступных генераторов:
cmake -G
В частности, многие программисты для ускорения сборки проектов предпочитают использовать Ninja:
cmake -G Ninja ..
ninja -j1
Выбор между отладочной и релизной сборкой осуществляется так:
cmake -DCMAKE_BUILD_TYPE=Release -G Ninja ..
cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -G Ninja ..
cmake -DCMAKE_BUILD_TYPE=MinSizeRel -G Ninja ..
# Debug используется по умолчанию
cmake -DCMAKE_BUILD_TYPE=Debug -G Ninja ..
Вместо запуска напрямую make или ninja можно сказать что-то вроде:
cmake —build . —config Release —target main
Можно выбрать конкретный компилятор для сборки проекта
cmake -DCMAKE_C_COMPILER= ` which clang ` \
-DCMAKE_CXX_COMPILER= ` which clang++ ` -G Ninja ..
… а также указать дополнительные флаги компиляции:
cmake -DCMAKE_C_FLAGS= «-O0 -g» -DCMAKE_CXX_FLAGS= «-O0 -g» ..
cmake -DCMAKE_C_FLAGS= «-O0 -g -fprofile-arcs -ftest-coverage» \
-DCMAKE_EXE_LINKER_FLAGS= «-lgcov» ..
В мире C/C++ нередко бывает, что сторонние библиотеки, использующие CMake, подключаются к проекту при помощи сабмодулей Git. Подключение таких библиотек к проекту осуществляется довольно просто:
cmake_minimum_required ( VERSION 2.8 )
include_directories ( deps/algorithms/include )
add_subdirectory ( deps/algorithms/src )
add_executable ( rbtree_example rbtree_example.c )
target_link_libraries ( rbtree_example CAlgorithms )
В свою очередь, у библиотеки файл src/CMakeList.txt должен быть примерно таким:
cmake_minimum_required ( VERSION 2.8 )
add_library ( CAlgorithms STATIC
struct/ilist.c
struct/rbtree.c
struct/htable.c
common/utils.c
)
Вообще, add_subdirectory может принимать путь до любого каталога, в котором есть файл CMakeLists.txt. Это позволяет разбивать проект на подпроекты даже в рамках одного репозитория. Опять же, в случае с библиотеками это позволяет поместить тесты в отдельный подпроект, который не будет собираться при подключении библиотеки в сторонние проекты.
Например, в корне библиотеки CMakeList.txt может быть таким:
cmake_minimum_required ( VERSION 2.8 )
add_subdirectory ( src )
add_subdirectory ( test )
Непосредственно тесты добавляются в проект следующим образом:
cmake_minimum_required ( VERSION 2.8 )
set ( CMAKE_C_FLAGS » $ -O0 -g» )
add_executable ( test_htable test_htable.c )
target_link_libraries ( test_htable CAlgorithms )
add_executable ( test_rbtree test_rbtree.c )
target_link_libraries ( test_rbtree CAlgorithms )
add_test ( test_htable «./test_htable» )
add_test ( test_rbtree «./test_rbtree» )
Запуск тестов осуществляется простой командой:
make test
# или, с включением отладочного вывода:
make test ARGS = «-V»
# или, если используете Ninja:
ninja test
… выполненной в каталоге build. Если вас интересует тема написания модульных тестов на C++, она более подробно раскрыта в заметке Тестирование кода на C++ с помощью Google Test.
Если же вы используете какой-нибудь PyTest, просто допишите в CMakeList.txt что-то вроде:
find_package ( PythonInterp REQUIRED )
add_test ( NAME python_test
COMMAND py.test —capture=no $ /tests/run.py )
Вывод тестов пишется в файл Testing/Temporary/LastTest.log. Кстати, подробности о переменных окружения, доступных в CMake, таких, как CMAKE_SOURCE_DIR, можно найти здесь.
Помимо рассмотренных выше возможностей часто можно встретить поддержку сборки проектов с различными опциями. В частности, это используется в Assimp и LLDB. При сборке проекта опции выбираются так:
cmake -DLLDB_DISABLE_CURSES: BOOL =TRUE .
cmake -DASSIMP_BUILD_ASSIMP_TOOLS=OFF .
Опции обычно описывают в документации, но в крайнем случае их можно посмотреть и через curses-интерфейс:
В рамках одного поста, конечно, не представляется возможным рассмотреть все возможности CMake. Однако представленной выше информации вам должно вполне хватить в 90% случаев. Полноценные рабочие примеры использования CMake вы найдете, например, в этом, этом, а также в этом репозиториях на GitHub. Примеры использования опций и условных операторов можно найти в репозиториях уже упомянутых Assimp и LLDB. Ну и, конечно же, массу полезного вы найдете на официальном сайте CMake.
А пользуетесь ли вы CMake и если да, используете ли какие-то его возможности, о которых не было рассказано выше?
Вы можете прислать свой комментарий мне на почту, или воспользоваться комментариями в Telegram-группе.
Как собрать проект x86 и x64 одновременно?
Допустим есть проект MainProject.vcxproj и проект HelpersLib.vcxproj. MainProject включает HelpersLib как ссылку на проект. Как можно собрать 2 версии проекта MainProject(x64+x86) независимо от того какая сейчас разрядность выбрана? Если бы небыло ссылки на проект, то можно было собрать 1 проект из другого:
Если же используется ссылка на проект, я так понимаю HelpersLib собирается для той платформы которая стоит в диспетчере конфигураций, и он же используется при ручной сборки MainProject для другой платформы (т.е. x86 конфликтует с x64). Есть какое-либо решение? Visual Studio пакетная сборка не интересует.
Введение в CMake
CMake — кроcсплатформенная утилита для автоматической сборки программы из исходного кода. При этом сама CMake непосредственно сборкой не занимается, а представляет из себя front-end. В качестве back-end`a могут выступать различные версии make и Ninja. Так же CMake позволяет создавать проекты для CodeBlocks, Eclipse, KDevelop3, MS VC++ и Xcode. Стоит отметить, что большинство проектов создаются не нативных, а всё с теми же back-end`ами.
Для того что бы собрать проект средствами CMake, необходимо в корне дерева исходников разместить файл CMakeLists.txt, хранящий правила и цели сборки, и произвести несколько простых шагов.
Разберёмся на примерах.
Пример 1. Hello, World:
Для начала напишем простейший хеловорлд и создадим структуру проекта:
main.cpp
#include int main(int argc, char** argv)
CMakeLists.txt
cmake_minimum_required(VERSION 2.8) # Проверка версии CMake. # Если версия установленой программы # старее указаной, произайдёт аварийный выход. add_executable(main main.cpp) # Создает исполняемый файл с именем main # из исходника main.cpp Синтаксис CMake похож на синтаксис bash, всё что после символа «#» является комментарием и обрабатываться программой не будет. CMake позволяет не засорять дерево исходных кодов временными файлами — очень просто и без лишних телодвижений сборка производится «Out-of-Source».
Создадим пустую директорию для временных файлов и перейдём туда.
fshp@panica-desktop:~$ mkdir tmp
fshp@panica-desktop:~$ cd tmp/
fshp@panica-desktop:~/tmp$
Теперь запустим команду cmake, передав ей в качестве параметра путь к папке с исходниками:
fshp@panica-desktop:~/tmp$ cmake ~/cmake/example_1/
…
— Build files have been written to: /home/fshp/tmp
fshp@panica-desktop:~/tmp$
fshp@panica-desktop:~/tmp$ ls
CMakeCache.txt CMakeFiles cmake_install.cmake Makefile
fshp@panica-desktop:~/tmp$
Видим, что в папке появилось несколько временных файлов, необходимых для сборки проекта.
Теперь можно запустить непосредственно make:
fshp@panica-desktop:~/tmp$ make
Scanning dependencies of target main
[100%] Building CXX object CMakeFiles/main.dir/main.cpp.o
Linking CXX executable main
[100%] Built target main
fshp@panica-desktop:~/tmp$ ./main
Hello, World!
fshp@panica-desktop:~/tmp$
Итак, наша программа собралась.
Папку tmp можно очищать\удалять без риска поломать исходники. Если CMakeLists.txt был изменен, то вызов make автоматически запустит cmake. Если исходники были перемещены, то нужно очистить временную директорию и запустить cmake вручную.
Пример 2. Библиотеки:
Если ваш проект содержит библиотеку, то CMake соберет ее без проблем.
Для этого усложним пример.
void hello_world(); foo.cpp
#include void hello_world()
main.cpp
#include "foo.h" int main(int argc, char** argv)
CMakeLists.txt
cmake_minimum_required(VERSION 2.8) # Проверка версии CMake. # Если версия установленой программы # старее указаной, произайдёт аварийный выход. project(hello_world) # Название проекта set(SOURCE_EXE main.cpp) # Установка переменной со списком исходников для исполняемого файла set(SOURCE_LIB foo.cpp) # Тоже самое, но для библиотеки add_library(foo STATIC $) # Создание статической библиотеки с именем foo add_executable(main $) # Создает исполняемый файл с именем main target_link_libraries(main foo) # Линковка программы с библиотекой Переменные могут хранить списки значений, разделённых пробелами\табуляциями\переносами:
set(SOURCE main.cpp foo.cpp) set(HEADER main.h foo.h) Оба варианта правильные
Что бы получить значение переменной ипользуем конструкцию:
Итак, эта версия нашего проекта включает в себя одну статическую библиотеку, собираемую из исходников. Если заменить «STATIC» на «SHARED», то получим библиотеку динамическую. Если тип библиотеки не указать, по умолчанию она соберётся как статическая.
При линковке указываются все необходимые библиотеки:
target_link_libraries(main foo ogg vorbis) Как и при ручной компиляции, имена библиотек указываются без стандартного префикса «lib».
Итак, сборка библиотек с CMake не вызывает проблем, при этом тип библиотеки статическая\динамическая меняется лишь одним параметром.
Пример 3. Подпроекты:
Подпроекты очень удобны, если ваша программа разбита на несколько библиотек или же проект состоит из нескольких программ.
Каждый подпроект является по сути полноценным проектом и может использоваться самостоятельно.
Теперь у нас «foo» находится в субдирректории и там же находится CMakeLists.txt подпроекта.
CMakeLists.txt
cmake_minimum_required(VERSION 2.8) # Проверка версии CMake. # Если версия установленой программы # старее указаной, произайдёт аварийный выход. project(hello_world) # Название проекта set(SOURCE_EXE main.cpp) # Установка переменной со списком исходников include_directories(foo) # Расположение заголовочных файлов add_executable(main $) # Создает исполняемый файл с именем main add_subdirectory(foo) # Добавление подпроекта, указывается имя дирректории target_link_libraries(main foo) # Линковка программы с библиотекой main.cpp
#include "foo.h" int main(int argc, char** argv)
foo/CMakeLists.txt
cmake_minimum_required(VERSION 2.8) # Проверка версии CMake. # Если версия установленой программы # старее указаной, произайдёт аварийный выход. project(foo) # Название проекта set(SOURCE_LIB foo.cpp) # Установка переменной со списком исходников add_library(foo STATIC $)# Создание статической библиотеки foo/foo.h
void hello_world(); foo/foo.cpp
#include void hello_world()
В файле подпроекта ничего нового для вас нет. А вот в основном файле новые команды:
include_directories(foo) main.cpp мы не меняли, а foo.h перенесли. Команда указывает компилятору, где искать заголовочные файлы. Может быть вызвана несколько раз. Хидеры будут искаться во всех указаных директориях.
add_subdirectory(foo) Указываем директорию с подпроектом, который будет собран как самостоятельный.
Вывод: проекты на CMake можно объединять в довольно сложные иерархические структуры, причем каждый подпроект в реальности является самостоятельным проектом, который в свою очередь может сам состоять из подпроектов. Это позволяет легко разбить вашу программу на необходимое количество отдельных модулей. Примером такого подхода может служить KDE.
Пример 4. Поиск библиотек:
CMake обладает достаточно развитыми средствами поиска установленых библиотек, правда они не встроеные, а реализованы в виде отдельных модулей. В стандартной поставке довольно много модулей, но некоторые проекты (например Ogre) поставляют свои. Они позволяют системе автоматически определить наличие необходимых для линковки проекта библиотек.
На debian модули располагаются в /usr/share/cmake-2.8/Modules/ (у вас версия может отличаться). За поиск библиотек отвечают модули, называющиеся FindNAME.cmake, где NAME — имя библиотеки.
find_package(SDL REQUIRED) if(NOT SDL_FOUND) message(SEND_ERROR "Failed to find SDL") return() else() include_directories($) endif() ########################################################## find_package(LibXml2 REQUIRED) if(NOT LIBXML2_FOUND) message(SEND_ERROR "Failed to find LibXml2") return() else() include_directories($) endif() ########################################################## find_package(Boost COMPONENTS thread-mt REQUIRED) if(NOT Boost_FOUND) message(SEND_ERROR "Failed to find boost::thread-mt.") return() else() include_directories($) endif() ########################################################## target_link_libraries($ $ $ $) Думаю, смысл должен быть понятен. Первый и второй блок — поиск библиотеки. Если в системе её нет, выведется сообщение об ошибке и завершается выполнение cmake. Третий блок похож, только он ищет не целый пакет библиотек, а лишь необходимый компонент. Каждый такой автоматизированый поиск определяет после выполнения как минимум 3 переменные:
SDL_FOUND, LIBXML2_FOUND, Boost_FOUND — признак присутствия бибилиотеки;
SDL_LIBRARY, LIBXML2_LIBRARIES, Boost_LIBRARIES — имена библиотек для линковки;
SDL_INCLUDE_DIR, LIBXML2_INCLUDE_DIR, Boost_INCLUDE_DIRS — пути к заголовочным файлам.
Если с первыми более или менее понятно, то вторые и третьи мне доставили много хлопот — половина имеет имена в единственном числе, половина — во множественном. Но оказалось, это легко отследить. В каждом модуле вначале есть коментарии, там описаны определяемые переменные. Посмотрите, например, /usr/share/cmake-2.8/Modules/FindLibXml2.cmake
Как видите, CMake способен сам определить наличие и местоположение необходимых библиотек и заголовочных файлов. В принципе, это должна уметь любая система автоматической сборки, иначе смысл в ней?
Пример 5. Внешние библиотеки и объектные файлы:
Если вы пишите для «дяди», а злой «дядя» любит самописные библиотеки и делиться исходниками не желает, поэтому присылает готовую библиотеку, то вы по адресу.
Объектные файлы в CMake стоят на ряду с исходниками — достаточно включить объектник в список файлов для компиляции.
С библиотеками потуже. Как известно, статическая библиотека это не что иное, как ar-архив, внутри которого лежат обычные объектники, никак не связаные между собой. Вы, наверное, уже догадались, как я поступал сначала. Да, просто потрошил библиотеку. Но потом был найден способ поэлегантнее:
add_library(netutil STATIC IMPORTED) set_property(TARGET netutil PROPERTY IMPORTED_LOCATION Binary/game_client/libnetutil.a) Слово «IMPORTED», указывает, что библиотека берётся извне.
В CMake каждая цель имеет параметры, а set_property позволяет их изменять.
Линкуется такая библиотека стандартно:
target_link_libraries($ netutil) Для динамических библиотек все аналогично, только тип «SHARED», расширение — «.so».
К сожалению, поддержка несистемных библиотек реализована немного костыльно. Возможно, я просто не знаю правильного варианта, поэтому буду рад, если «ткнете мордочкой». С другой стороны это не навороченый экзоскелет с системой жизнеобеспечения, а простейший костыль из двух строк.
Генераторы:
Как было сказано в начале, CMake умеет генерировать множество различных видов проектов. Это удобно и позволяет использовать CMake для практически любой популярной IDE.
Если запустить cmake без параметров, в конце будут описаны доступные генераторы. Пользоваться так:
fshp@panica-desktop:~/tmp$ cmake ~/cmake/example_3/ -G «KDevelop3 — Unix Makefiles»
Заключение:
Это не перевод мануала, а результат использования CMake в одном коммерческом проекте. Буду рад, если статья поможет хотя бы одному человеку — на русском языке подобной документации довольно мало.
- один проект — один файл. Не нужно хранить кучу скриптов настройки, сборки и прочего хлама;
- Скорость работы в сравнении с autotools;
- простой и понятный синтаксис, конечно с элегантностью питона не потягаться, но и не брейнфак, в конце концов.;
- является front-end`ом для множества IDE;
- отображение прогресса — довольно удобно;
- цветной вывод — в серые будни немного краски не помешает;
Как собрать cmake проект в vscode
Visual Studio Code – это мощное интегрированное средство разработки, которое предоставляет разработчикам широкий набор инструментов и расширений для создания и управления проектами на различных языках программирования. Одним из таких инструментов является CMake – мощный и гибкий инструмент для управления процессом сборки программного обеспечения.
Если вы разрабатываете проект на языке C++ с использованием CMake и Visual Studio Code, вам необходимо настроить свою рабочую среду таким образом, чтобы она позволяла вам собирать проекты в CMake. Это важно, потому что с помощью CMake можно легко управлять зависимостями проекта, а также автоматизировать процесс сборки и установки.
В этой статье я расскажу вам, как правильно настроить среду разработки в Visual Studio Code для сборки проекта в CMake. Я расскажу вам о необходимых инструментах и расширениях, а также о процессе настройки и сборки проекта. Следуя этим инструкциям, вы сможете собрать свой проект в CMake и наслаждаться удобством его использования.
Проект
Проект в CMake состоит из набора исходных файлов, которые разбиваются на несколько модулей или компонентов. Каждый модуль может содержать свои исходные файлы и зависимости от других модулей.
Для создания проекта в CMake необходимо создать файл CMakeLists.txt, который описывает структуру проекта и настройки компиляции. В этом файле задаются пути к исходным файлам, используемым библиотекам и другие параметры сборки.
Далее проект можно собрать с помощью команды cmake, которая создаст нужные файлы для сборки проекта. Затем, с помощью команды make проект можно скомпилировать и получить исполняемый файл или библиотеки.
Интеграция проекта CMake с Visual Studio Code позволяет удобно управлять сборкой и отладкой проекта. В Visual Studio Code можно настроить сборку проекта, запускать его в отладчике и просматривать результаты сборки и отладки.
Система сборки CMake и интеграция с Visual Studio Code облегчают процесс разработки проектов на C++, позволяя эффективно управлять зависимостями и компилировать код.
Сборка
Для сборки проекта с использованием CMake в Visual Studio Code, вам потребуется выполнить следующие шаги:
- Убедитесь, что у вас установлен CMake и Visual Studio Code.
- Откройте папку с проектом в Visual Studio Code.
- В корневой папке проекта создайте файл CMakeLists.txt и заполните его соответствующими инструкциями по сборке проекта.
- Откройте командную строку Visual Studio Code, выбрав «Terminal» -> «New Terminal».
- В терминале введите команду cmake . для создания файлов сборки в папке проекта.
- После успешного выполнения команды cmake, создайте директорию build и перейдите в неё.
- В терминале выполните команду cmake —build . для начала сборки проекта.
- После успешной сборки проекта, вы получите исполняемый файл или библиотеку в директории build.
После завершения этих шагов, ваш проект будет успешно собран с использованием CMake в Visual Studio Code.
CMake
Основной принцип работы CMake заключается в использовании конфигурационных файлов CMakeLists.txt, которые описывают структуру проекта, зависимости и параметры сборки. Эти файлы используются для генерации файлов сборки для различных систем сборки, таких как Make, Ninja, Visual Studio и других.
Создание проекта с использованием CMake в Visual Studio Code является отличным выбором для разработчиков, которые хотят иметь универсальное средство сборки, способное работать на различных операционных системах и платформах.
В Visual Studio Code можно настроить среду разработки для проекта на основе CMake. Для этого необходимо установить расширение CMake Tools, которое предоставит все необходимые возможности для работы с проектами на CMake.
| Преимущества CMake: | Недостатки CMake: |
|---|---|
| Кросс-платформенность | Сложность изучения и настройки |
| Единый подход к настройке | Некоторые ограничения в синтаксисе |
| Интеграция с различными системами сборки | Может потребоваться дополнительное конфигурирование |
Использование CMake в Visual Studio Code позволяет создавать, настраивать и собирать проекты различной сложности. Он предоставляет простой и гибкий способ организации сборки приложений и управления зависимостями.
С помощью CMake в Visual Studio Code вы можете создавать проекты на C и C++, настраивать параметры сборки, контролировать процесс сборки, а также использовать дополнительные инструменты и плагины, предоставляемые CMake Tools.
Если вы хотите упростить сборку вашего проекта, обеспечить его переносимость и универсальность, то использование CMake в Visual Studio Code будет отличным выбором.
Visual Studio Code
Одним из преимуществ Visual Studio Code является его расширяемость. С помощью плагинов можно легко добавить поддержку для различных языков программирования, использовать инструменты для отладки и так далее. VS Code также предоставляет широкие возможности для настройки среды разработки – то есть, вы можете выбрать те инструменты и функции, которые наиболее удобны вам.
Для разработки проектов на языке C++ в Visual Studio Code можно использовать расширение C/C++. С его помощью вы сможете написать код, собрать проект и выполнить его. Настройка проекта осуществляется с использованием файла конфигурации CMake, который определяет настройки сборки и зависимости проекта.
Чтобы начать разработку C++ проекта в Visual Studio Code, вам потребуется установить несколько компонентов:
- Visual Studio Code
- Расширение для C/C++
- CMake
- Компилятор C++ (например, GCC или Clang)
После установки всех необходимых компонентов вы сможете создавать и собирать проекты на языке C++ в Visual Studio Code. Использование системы сборки CMake позволяет легко портировать проекты между различными платформами и средами разработки, а также управлять зависимостями проекта.
Инструкция
Для сборки проекта в CMake в Visual Studio Code следуйте этой инструкции:
- Установите Visual Studio Code и CMake. Если вы их еще не установили, загрузите их с официальных сайтов.
- Откройте папку с проектом в Visual Studio Code. В меню выберите «Файл» -> «Открыть папку» и выберите папку, содержащую файл CMakeLists.txt.
- Установите расширение «CMake Tools». В боковой панели выберите «Расширения» и найдите «CMake Tools». Установите его, затем перезапустите Visual Studio Code.
- Настройте файлы CMakeLists.txt. Откройте файл CMakeLists.txt и укажите настройки для вашего проекта, такие как исходные файлы, компилятор и т. д. Это важно, чтобы CMake мог правильно собрать ваш проект.
Теперь ваш проект должен быть собран успешно в Visual Studio Code с использованием CMake. Вы можете запускать и отлаживать его внутри среды разработки.
Плагины
Visual Studio Code предоставляет возможность расширять его функциональность с помощью различных плагинов. Вот некоторые популярные плагины, которые могут быть полезны при работе с проектами CMake:
- CMake Tools — предоставляет интеграцию и поддержку CMake в Visual Studio Code. Позволяет собирать и запускать проекты, настраивать переменные среды и выполнять другие операции, связанные с процессом сборки проекта.
- CMake — добавляет подсветку синтаксиса для файлов CMakeLists.txt и cmake файлов.
- Code Runner — позволяет запускать отдельные файлы C++ или сценарии с клавиатуры без необходимости создания целого проекта.
- GitLens — интегрирует Git в Visual Studio Code, предоставляя информацию о коммитах, авторах и изменениях в исходном коде. Это может быть полезно при работе с проектами, развернутыми из репозитория на GitHub или других хостингах.
- CMake Generator — добавляет возможность генерации файлов для различных генераторов CMake. Плагин позволяет выбрать нужный генератор и сгенерировать файлы для сборки проекта.
Это лишь некоторые плагины, доступные в Visual Studio Code, чтобы оптимизировать и упростить работу с проектами CMake. Вы можете найти больше плагинов в маркетплейсе Visual Studio Code и выбрать те, которые наиболее подходят для ваших потребностей.
Отладка
Visual Studio Code предоставляет удобный инструмент для отладки проектов, которые собраны с использованием CMake. Для настройки отладки вам понадобится создать конфигурационный файл launch.json.
1. Откройте вкладку «Отладка» в боковой панели Visual Studio Code.
2. Нажмите на шестеренку, чтобы открыть выпадающее меню «Настройки отладки» и выберите пункт «Создать файл launch.json».
3. Выберите «CMake» в качестве шаблона для файла launch.json.
4. Укажите путь к исполняемому файлу вашего проекта в поле «program».
5. Укажите аргументы командной строки, если необходимо, в поле «args».
6. Укажите директорию для рабочей области, если требуется, в поле «cwd».
7. Добавьте дополнительные настройки для отладчика CMake в раздел «setupCommands».
8. Сохраните файл launch.json.
После настройки файла launch.json вы сможете использовать инструменты отладки в Visual Studio Code. Вы можете установить точки останова, выполнять код пошагово, просматривать значения переменных и многое другое при отладке вашего проекта.
Примечание: перед запуском отладки убедитесь, что ваш проект собран с поддержкой отладки. Для этого при генерации проекта с помощью CMake добавьте флаг -DCMAKE_BUILD_TYPE=Debug.
Настройки
Для сборки проекта в CMake в Visual Studio Code необходимо настроить некоторые параметры.
1. Установка CMake extension
Для начала работы вам понадобится установить расширение «CMake» для Visual Studio Code. Это можно сделать следующим образом:
- Откройте Visual Studio Code.
- Нажмите на иконку с расширениями в левой боковой панели.
- В поисковой строке введите «CMake» и найдите расширение «CMake Tools» с автором «vector-of-bool».
- Нажмите на кнопку «Install» для установки расширения.
2. Настройка пути к CMake
После установки расширения «CMake Tools» необходимо указать путь к исполняемому файлу CMake:
- Нажмите на клавишу F1 на клавиатуре, чтобы открыть панель команд Visual Studio Code.
- Введите «CMake: Edit User-Local CMake Kits» и нажмите Enter.
- Следуйте инструкциям для добавления пути к исполняемому файлу CMake.
3. Настройка проекта в CMake
Теперь можно настроить проект в CMake:
- Откройте папку проекта в Visual Studio Code.
- Перейдите во вкладку «CMake» внизу окна.
- Нажмите на кнопку «+» рядом с «Configurations» и выберите нужную конфигурацию сборки (например, «Debug» или «Release»).
- Укажите путь к папке с исходными файлами проекта.
- Нажмите на кнопку «Configure» для настройки проекта в CMake.
После выполнения этих настроек вы сможете собирать и запускать проект в CMake в Visual Studio Code.