CMake: How to set up source, library and CMakeLists.txt dependencies?

by

Adding the same subdirectory multiple times is out of question, it’s not how CMake is intended to work. There are two main alternatives to do it in a clean way:

  1. Build your libraries in the same project as your app. Prefer this option for libraries you’re actively working on (while you’re working on the app) so they are likely to be frequently edited and rebuilt. They will also show up in the same IDE project.

  2. Build your libraries in an external project (and I don’t mean ExternalProject). Prefer this option for libraries that are just used by your app but you’re not working on them. This is the case for most third-party libraries. They will not clutter your IDE workspace, either.

Method #1

  • your app’s CMakeLists.txt adds the subdirectories of the libraries (and your libs’ CMakeLists.txt‘s don’t)
  • your app’s CMakeLists.txt is responsible to add all immediate and transitive dependencies and to add them in the proper order
  • it assumes that adding the subdirectory for libx will create some target (say libx) that can be readily used with target_link_libraries

As a sidenote: for the libraries it’s a good practice to create a full-featured library target, that is, one that contains all the information needed to use the library:

add_library(LibB Src/b.cc Inc/b.h)
target_include_directories(LibB PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/Inc>)

So the location of include directories of the library can remain an internal affair of the lib. You will only have to do this;

target_link_libraries(LibC LibB)

then the include dirs of LibB will also be added to the compilation of LibC. Use the PRIVATE modifier if LibB is not used by the public headers of LibC:

target_link_libraries(LibC PRIVATE LibB)

Method #2

Build and install your libraries in seperate CMake projects. Your libraries will install a so-called config-module which describes the locations of the headers and library files and also compile flags. Your app’s CMakeList.txt assumes the libraries has already been built and installed and the config-modules can be found by the find_package command. This is a whole another story so I won’t go into details here.

A few notes:

  • You can mix #1 and #2 as in most cases you will have both unchanging, third-party libs and your own libraries under development.
  • A compromise between #1 and #2 is using the ExternalProject module, preferred by many. It’s like including the external projects of your libraries (built in their own build tree) into your app’s project. In way it combines the disadvantages of both approaches: you can’t use your libraries as targets (because they’re in a different project) and you can’t call find_package (because the libs are not installed the time your app’s CMakeLists is configuring).
  • A variant of #2 is to build the library in an external project but instead of installing the artifacts use them from their source/build locations. For more about this see the export() command.

More Related Contents:

  1. How to properly add include directories with CMake
  2. How to link C++ program with Boost using CMake
  3. Debug vs Release in CMake
  4. How to detect C++11 support of a compiler with CMake
  5. Combining several static libraries into one using CMake
  6. How to properly link libraries with cmake?
  7. Error LNK1104: cannot open file ‘Debug\MyProjectLib.lib’
  8. OS specific instructions in CMAKE: How to?
  9. How to create a shared library with cmake?
  10. Override compile flags for single files
  11. CMake unable to determine linker language with C++
  12. CMake: include library dependencies in a static library
  13. CMake linking against shared library on windows: error about not finding .lib file
  14. CMake ExternalProject_Add() and FindPackage()
  15. In CMake, how can I test if the compiler is Clang?
  16. How to use c++20 modules with CMake?
  17. cmake include header into every source file
  18. How to build cmake ExternalProject while configurating main one?
  19. Handling header files dependencies with cmake
  20. How to handle a transitive dependency conflict using Git submodules and CMake?
  21. Add external libraries to CMakeList.txt c++
  22. How do I iterate over all CMake targets programmatically?
  23. cmake – Global linker flag setting (for all targets in directory)
  24. preferred cmake project structure
  25. What is the difference between include_directories and target_include_directories in CMake?
  26. Using pre-compiled headers with CMake
  27. How to use CMAKE_EXPORT_COMPILE_COMMANDS?
  28. The proper way of forcing a 32-bit compile using CMake
  29. Adding multiple executables in CMake
  30. CMake: target_include_directories() prints an error when I try to add the source directory itself, or one of its subdirectories

Leave a Comment