CodeBlanks Logo Icon CodeBlanks
Login Register

Multi-project

Learn multi-project structure with CMake.

Multi-project structure

Large projects split into multiple subdirectories: each has its own CMakeLists.txt. The top-level file includes subdirectories with the add_subdirectory command. This keeps the code modular.

Typical layout: a root CMakeLists.txt, a lib/ subdirectory for the library, an app/ subdirectory for the application. The root file calls add_subdirectory(lib) and add_subdirectory(app). Each subdirectory CMakeLists defines its own targets. Variable and target sharing between parent and child is automatic.

Library and application separation

In a modular project the lib/ directory defines a library with add_library. The app/ directory defines the application with add_executable and links to the library with target_link_libraries. This lets the library be reused in other projects.

Example: in lib/CMakeLists.txt write add_library(mylib utils.cpp). In app/CMakeLists.txt write add_executable(myapp main.cpp) and target_link_libraries(myapp PRIVATE mylib). The root file calls both with add_subdirectory. The dependency direction is clear: app depends on lib; lib is independent.

Practice Write the multi-project root file

Write the root CMakeLists.txt. Add cmake_minimum_required(VERSION 3.20) and project(MyApp). Include two subdirectories with add_subdirectory(lib) and add_subdirectory(app).

Starter code

main.cpp
# CMakeLists.txt (root)
# Add cmake_minimum_required, project and add_subdirectory

Sample solution

main.cpp
cmake_minimum_required(VERSION 3.20)
project(MyApp)
add_subdirectory(lib)
add_subdirectory(app)

Expected output

Project structure ready

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What does add_subdirectory do?

  • Creates a new library
  • Processes a subdirectory's CMakeLists Correct answer
  • Sets the output directory
  • Changes the compiler

Explanation: add_subdirectory brings a subdirectory's CMakeLists.txt into the build.

2 Match each piece to its role

Term Meaning
add_subdirectory(lib) Adds the lib directory
add_subdirectory(app) Adds the app directory
lib/CMakeLists.txt Library target
app/CMakeLists.txt Application target

3 Complete the add_subdirectory command

Question 
____(lib)
Answer 
add_subdirectory(lib)

Explanation: add_subdirectory(lib) brings the lib directory into the build.

All lessons in Advanced

1 Modern C++

  1. C++17 and C++20
  2. Structured bindings
  3. if constexpr
  4. Concepts
  5. Ranges
  6. Summary - Modern C++

2 Variadic templates

  1. Variadic templates
  2. Parameter pack
  3. Fold expressions
  4. Perfect forwarding
  5. std::tuple
  6. Summary - Variadic templates

3 Type traits

  1. What are type traits?
  2. is_integral
  3. enable_if
  4. conditional
  5. decay and remove_reference
  6. Summary - Type traits

4 Concurrency basics

  1. std::thread
  2. std::mutex
  3. std::lock_guard
  4. std::async
  5. std::future
  6. Summary - Concurrency

5 Atomic and memory order

  1. std::atomic
  2. memory_order
  3. Compare-exchange
  4. atomic flag
  5. Fetch and add
  6. Summary - Atomic

6 Design patterns

  1. Singleton
  2. Factory
  3. Strategy
  4. Observer
  5. Decorator
  6. Summary - Design patterns

7 Testing basics

  1. GoogleTest
  2. TEST macro
  3. ASSERT vs EXPECT
  4. Test fixtures
  5. Mock
  6. Summary - Testing basics

8 Build systems

  1. CMake basics
  2. CMakeLists.txt
  3. find_package
  4. Multi-project
  5. Ninja and Make
  6. Summary - Build systems

9 Serialization

  1. Binary serialization
  2. Text serialization
  3. JSON library
  4. Versioning
  5. Custom serialization
  6. Summary - Serialization

10 Networking

  1. Socket basics
  2. TCP client
  3. TCP server
  4. Boost.Asio
  5. HTTP client
  6. Summary - Networking

11 Concepts

  1. Defining concepts
  2. requires
  3. Standard concepts
  4. Compound requirements
  5. Concept overloading
  6. Summary - Concepts

12 Coroutines

  1. What are coroutines?
  2. co_await
  3. co_return
  4. co_yield
  5. Task type
  6. Summary - Coroutines

13 Advanced error handling

  1. Exception hierarchy
  2. Exception safety
  3. RAII and exceptions
  4. std::expected
  5. noexcept
  6. Summary - Advanced error handling

14 Advanced final

  1. Project design
  2. Modern C++
  3. Concurrency
  4. Design patterns
  5. Putting it together