Что это за программа cmake

Содержание

cmake учебник
Начало работы с cmake

CMake — это инструмент для определения и управления сборками кода, прежде всего для C ++.

CMake — это кросс-платформенный инструмент; идея состоит в том, чтобы иметь единое определение того, как строится проект, — который переводится в конкретные определения построения для любой поддерживаемой платформы.

Это достигается путем сопряжения с различными платформами, специфичными для платформы; CMake — это промежуточный шаг, который генерирует ввод данных для разных конкретных платформ. В Linux CMake генерирует Makefiles; в Windows он может создавать проекты Visual Studio и т. д.

Поведение сборки определяется в файлах CMakeLists.txt — по одному в каждом каталоге исходного кода. Файл CMakeLists каждого каталога определяет, что должна делать система сборки в этом конкретном каталоге. Он также определяет, какие подкаталоги должны обрабатывать CMake.

Типичные действия включают:

Создайте библиотеку или исполняемый файл из некоторых исходных файлов в этом каталоге.
Добавьте путь к пути include-path, который используется во время сборки.
Определите переменные, которые будет использовать buildsystem в этом каталоге, и в его подкаталогах.
Создайте файл на основе конкретной конфигурации сборки.
Найдите библиотеку, которая находится где-то в исходном дереве.

Окончательные файлы CMakeLists могут быть очень четкими и понятными, поскольку каждый из них настолько ограничен по объему. Каждый из них обрабатывает столько же сборки, сколько присутствует в текущем каталоге.

Вопрос — ответ #3 — Что такое компиляция программы? Что такое make, CMake?

Для официальных ресурсов на CMake см. Документацию и учебник CMake.

Версии

Версия Дата выхода

3,9	2017-07-18
3,8	2017-04-10
3,7	2016-11-11
3,6	2016-07-07
3,5	2016-03-08
3,4	2015-11-12
3,3	2015-07-23
3,2	2015-03-10
3,1	2014-12-17
3.0	2014-06-10
2.8.12.1	2013-11-08
2.8.12	2013-10-11
2.8.11	2013-05-16
2.8.10.2	2012-11-27
2.8.10.1	2012-11-07
2.8.10	2012-10-31
2.8.9	2012-08-09
2.8.8	2012-04-18
2.8.7	2011-12-30
2.8.6	2011-12-30
2.8.5	2011-07-08
2.8.4	2011-02-16
2.8.3	2010-11-03
2.8.2	2010-06-28
2.8.1	2010-03-17
2,8	2009-11-13
2,6	2008-05-05

Установка CMake

Перейдите на страницу загрузки CMake и получите двоичный файл для вашей операционной системы, например Windows, Linux или Mac OS X. В Windows дважды щелкните двоичный файл для установки. В Linux запускается двоичный файл с терминала.

CMake основы

В Linux вы также можете установить пакеты из диспетчера пакетов дистрибутива. На Ubuntu 16.04 вы можете установить командную строку и графическое приложение с помощью:

sudo apt-get install cmake sudo apt-get install cmake-gui

В FreeBSD вы можете установить командную строку и графическое приложение на основе Qt с помощью:

pkg install cmake pkg install cmake-gui

В Mac OSX, если вы используете один из менеджеров пакетов, доступных для установки вашего программного обеспечения, наиболее заметным из которых является MacPorts ( MacPorts ) и Homebrew ( Homebrew ), вы также можете установить CMake через один из них. Например, в случае MacPorts, введите следующие

sudo port install cmake

установит CMake, в то время как в случае использования ящика Homebrew, который вы наберете

brew install cmake

После того, как вы установили CMake, вы можете легко проверить, выполнив следующие

cmake —version

Вы должны увидеть что-то похожее на следующее

cmake version 3.5.1 CMake suite maintained and supported by Kitware (kitware.com/cmake).

Переключение между типами сборки, например отладка и выпуск

CMake знает несколько типов сборки, которые обычно влияют на параметры компилятора и компоновщика по умолчанию (такие как создаваемая отладочная информация) или альтернативные пути кода.

По умолчанию CMake может обрабатывать следующие типы сборки:

Отладка : обычно классическая сборка отладки, включая отладочную информацию, отсутствие оптимизации и т. Д.
Выпуск : типичная версия сборки без отладочной информации и полной оптимизации.
RelWithDebInfo:: То же, что и Release , но с информацией об отладке.
MinSizeRel : специальная версия выпуска, оптимизированная для размера.

Как обрабатываются конфигурации, зависит от используемого генератора.

Некоторые генераторы (например, Visual Studio) поддерживают несколько конфигураций. CMake будет генерировать все конфигурации сразу, и вы можете выбрать из IDE или использовать —config CONFIG (с cmake —build ), какую конфигурацию вы хотите построить. Для этих генераторов CMake будет стараться изо всех сил генерировать структуру каталогов сборки, чтобы файлы из разных конфигураций не наступали друг на друга.

Генераторы, которые поддерживают только одну конфигурацию (например, Unix Make-файлы), работают по-разному. Здесь CMAKE_BUILD_TYPE активная конфигурация определяется значением переменной CMake CMAKE_BUILD_TYPE .

Например, чтобы выбрать другой тип сборки, можно выполнить следующие команды командной строки:

cmake -DCMAKE_BUILD_TYPE=Debug path/to/source cmake -DCMAKE_BUILD_TYPE=Release path/to/source

Сценарий CMake должен избегать установки самого CMAKE_BUILD_TYPE , так как обычно это отвечает за ответственность пользователей.

Для генераторов с одним коннектором для переключения конфигурации требуется перезапуск CMake. Последующая сборка, скорее всего, перезапишет объектные файлы, созданные более ранней конфигурацией.

Простой проект «Hello World»

Учитывая исходный файл C ++ main.cpp определяющий функцию main() , сопровождающий файл CMakeLists.txt (со следующим содержимым) будет инструктировать CMake для генерации соответствующих инструкций сборки для текущей системы и компилятора C ++ по умолчанию.

#include int main()

CMakeLists.txt

cmake_minimum_required(VERSION 2.4) project(hello_world) add_executable(app main.cpp)

cmake_minimum_required(VERSION 2.4) устанавливает минимальную версию CMake, необходимую для оценки текущего скрипта.
project(hello_world) запускает новый проект CMake. Это вызовет много внутренней логики CMake, особенно при обнаружении компилятора C и C ++ по умолчанию.
С помощью add_executable(app main.cpp) создается целевое app для сборки, которое будет вызывать сконфигурированный компилятор с некоторыми стандартными флагами для текущего параметра для компиляции исполняемого app из данного исходного файла main.cpp .

Командная строка (In-Source-Build, не рекомендуется)

> cmake . . > cmake —build .

cmake . обнаруживает компилятор, оценивает CMakeLists.txt в данном . и генерирует среду сборки в текущем рабочем каталоге.

cmake —build . команда является абстракцией для необходимого вызова build / make.

Командная строка (рекомендуется использовать Out-of-Source)

Чтобы ваш исходный код был чистым от каких-либо артефактов сборки, вы должны делать сборки «вне источника».

> mkdir build > cd build > cmake .. > cmake —build .

Или CMake также может абстрагировать основные команды оболочки платформы из примера выше:

> cmake -E make_directory build > cmake -E chdir build cmake .. > cmake —build build

«Hello World» с несколькими исходными файлами

Сначала мы можем указать каталоги файлов заголовков include_directories() , тогда нам нужно указать соответствующие исходные файлы целевого исполняемого файла с помощью add_executable() и убедиться, что в исходных файлах есть только одна функция main() .

Ниже приведен простой пример: все файлы предполагаются помещенными в каталог PROJECT_SOURCE_DIR .

main.cpp

#include «foo.h» int main()

foo.h

void foo();

foo.cpp

#include #include «foo.h» void foo()

CMakeLists.txt

cmake_minimum_required(VERSION 2.4) project(hello_world) include_directories($) add_executable(app main.cpp foo.cpp) # be sure there’s exactly one main() function in the source files

Мы можем следовать той же процедуре в приведенном выше примере, чтобы построить наш проект. Затем выполнение app распечатает

>./app Hello World!

«Привет мир» в качестве библиотеки

В этом примере показано, как развернуть программу «Hello World» в качестве библиотеки и как связать ее с другими объектами.

Скажем, у нас есть тот же набор исходных / заголовочных файлов, что и в примере http://www.riptutorial.com/cmake/example/22391/-hello-world—with-multiple-source-files . Вместо создания из нескольких исходных файлов мы можем сначала развернуть foo.cpp как библиотеку с помощью add_library() а затем связать ее с основной программой с помощью target_link_libraries() .

Мы модифицируем CMakeLists.txt для

cmake_minimum_required(VERSION 2.4) project(hello_world) include_directories($) add_library(applib foo.cpp) add_executable(app main.cpp) target_link_libraries(app applib)

Введение в 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».

Создадим пустую директорию для временных файлов и перейдём туда.

Теперь запустим команду cmake, передав ей в качестве параметра путь к папке с исходниками:

Видим, что в папке появилось несколько временных файлов, необходимых для сборки проекта.
Теперь можно запустить непосредственно make:

Итак, наша программа собралась.
Папку 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

#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 без параметров, в конце будут описаны доступные генераторы. Пользоваться так:

Заключение:

Это не перевод мануала, а результат использования CMake в одном коммерческом проекте. Буду рад, если статья поможет хотя бы одному человеку — на русском языке подобной документации довольно мало.

один проект — один файл. Не нужно хранить кучу скриптов настройки, сборки и прочего хлама;
Скорость работы в сравнении с autotools;
простой и понятный синтаксис, конечно с элегантностью питона не потягаться, но и не брейнфак, в конце концов.;
является front-end`ом для множества IDE;
отображение прогресса — довольно удобно;
цветной вывод — в серые будни немного краски не помешает;

Знакомство с CMake. Часть 1. Установка, CMakeLists.txt, сборка.

Многие, кто начинал создавать собственные программы, пользовался какой-либо системой сборки. В общем, система сборки – это набор инструментов, облегчающий работу с компилятором. Это включает в себя компиляцию, линковку, установку, а также сбор исходных файлов для передачи их компилятору и слежение за зависимостями.

Также современные системы сборки облегчают работу с библиотеками, позволяют создавать переносимые проекты и выполняют ещё массу других вкусностей. Эта статья посвящена популярной системе сборки CMake и расскажет, как правильно её установить и настроить, а также будет рассмотрен простой пример её использования. Она рассчитана на тех, что хоть немного знаком с понятиями make, Makefile, компиляция, линковка.

Установка в Linux.

Для популярных дистрибутивов Linux типа Debian, Gentoo, Fedora и т.д. CMake давно лежит в официальных репозиториях. Нам нужно всего лишь установить пакет cmake с помощью менеджера пакетов. Как правило, он устанавливается в системные директории, и необходимости править переменные окружения нету. Можете проверить её работоспособность, выполнив

cmake —version

Если же в репозитории нет такого пакета, то можно его собрать вручную. Скачиваем Unix/Linux Source, например, cmake-3.5.0-rc3.tar.gz, распаковываем и собираем:

tar -xzf cmake-3.5.0-rc3.tar.gz sudo make install

Если нет необходимости устанавливать в системную /usr директорию, можно в аргументе —prefix прописать нужный корень установки. По умолчанию, без явного указания —prefix, установка будет произведена в /usr/local. -j используется для ускорения сборки, например, на 4-х ядерном процессоре можно указать -j4, и сборка будет вестись параллельно в 4 потока.

Установка в Windows.

Для Windows на сайте CMake лежит установочный файл msi. Рекомендую при установке отметить галочку добавления пути в переменные окружения PATH для всех пользователей. Тогда, после перелогинивания, CMake будет доступен из любого места. Проверить можно, открыв cmd и выполнив тот же

cmake —version

Основная цель работы CMake – создание Makefile или проекта для конкретной среды программирования по файлу проекта CMakeLists.txt. За тип создаваемых файлов отвечает аргумент -G. Можно посмотреть поддерживаемые генераторы, выполнив

cmake -G

Т.е. любой проект с использованием этой системы сборки начинается с создания CMakeLists.txt, в котором описывается проект.

CMakeLists.txt

Основную документацию можно посмотреть на сайте CMake, а здесь я расскажу коротко об основных правилах написания этого файла. В этом файле описываются исходные файлы, подключаемые библиотеки, параметры компиляции, подпроекты и правила установки. В одном файле разрешается создавать несколько исполняемых файлов или библиотек и подключать несколько подпроектов.

Под подпроектом я подразумеваю просто другую папку с CMakeLists.txt. В этом и состоит основная прелесть CMake – он не накладывает никаких ограничений на состав и сложность проекта. Один файл может описывать как самостоятельное приложение, так и быть корневым файлом сложного программного комплекса. Или, например, в одном файле можно описать сборку библиотеки и исполняемого файла, использующего эту библиотеку, а также тут же подключить ещё парочку подпроектов.

Итак, пример простейшего CMakeLists.txt:

Источник: admins.su

Записки программиста

Некоторое время назад мы познакомились с 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, можно найти здесь.

Введение в CMake

Пример 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, передав ей в качестве параметра путь к папке с исходниками:

Пример 2. Библиотеки:

void hello_world();
foo.cpp
#include void hello_world()
main.cpp
#include «foo.h» int main(int argc, char** argv)
CMakeLists.txt

Переменные могут хранить списки значений, разделённых пробеламитабуляциямипереносами:

set(SOURCE main.cpp foo.cpp) set(HEADER main.h foo.h)

Оба варианта правильные
Что бы получить значение переменной ипользуем конструкцию:

target_link_libraries(main foo ogg vorbis)

Как и при ручной компиляции, имена библиотек указываются без стандартного префикса «lib».

Пример 3. Подпроекты:

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) # Линковка программы с библиотекой
foo/CMakeLists.txt
cmake_minimum_required(VERSION 2.8) # Проверка версии CMake. # Если версия установленой программы # старее указаной, произайдёт аварийный выход. project(foo) # Название проекта set(SOURCE_LIB foo.cpp) # Установка переменной со списком исходников add_library(foo STATIC $)# Создание статической библиотеки

В файле подпроекта ничего нового для вас нет. А вот в основном файле новые команды:

include_directories(foo)

add_subdirectory(foo)

Указываем директорию с подпроектом, который будет собран как самостоятельный.

Пример 4. Поиск библиотек:

CMake обладает достаточно развитыми средствами поиска установленых библиотек, правда они не встроеные, а реализованы в виде отдельных модулей. В стандартной поставке довольно много модулей, но некоторые проекты (например Ogre) поставляют свои.
На debian модули располагаются в /usr/share/cmake-2.8/Modules/ (у вас версия может отличаться).

Пример 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)

Генераторы:

Как было сказано в начале, CMake умеет генерировать множество различных видов проектов.
Если запустить cmake без параметров, в конце будут описаны доступные генераторы. Пользоваться так:

Заключение:

Чем понравился CMake лично мне:

один проект — один файл. Не нужно хранить кучу скриптов настройки, сборки и прочего хлама;
Скорость работы в сравнении с autotools;
простой и понятный синтаксис;
является front-end`ом для множества IDE;
отображение прогресса — довольно удобно;
цветной вывод — в серые будни немного краски не помешает;

Для Sublime Text есть плагин, добавляющий подсветку синтаксиса CMake, он так и называется — «CMake».
Примеры

Источник: savepearlharbor.com

cmake учебник Начало работы с cmake

Версии

Установка CMake

Переключение между типами сборки, например отладка и выпуск

Простой проект «Hello World»

«Hello World» с несколькими исходными файлами

«Привет мир» в качестве библиотеки

Введение в CMake

Пример 1. Hello, World:

Пример 2. Библиотеки:

Пример 3. Подпроекты:

Пример 4. Поиск библиотек:

Пример 5. Внешние библиотеки и объектные файлы:

Генераторы:

Заключение:

Знакомство с CMake. Часть 1. Установка, CMakeLists.txt, сборка.

Установка в Linux.

Установка в Windows.

CMakeLists.txt

Записки программиста

Введение в CMake

Пример 1. Hello, World:

Пример 2. Библиотеки:

Пример 3. Подпроекты:

Пример 4. Поиск библиотек:

Пример 5. Внешние статические библиотеки и объектные файлы:

Генераторы:

Заключение:

Для чего нужна программа компилятор

Программа смешанное белье для чего

Токси риск программа для чего

Программа аршин метрология для чего

Программа чек пфр для чего

Для чего предназначена программа стили

Для чего нужна программа тренажер

Для чего нужна программа apkpure

cmake учебник
Начало работы с cmake