CodeBlanks Logo Icon CodeBlanks
Login Register

Summary - Build systems

Combine CMake, find_package and multi-project to set up a project structure.

Summary: setting up a CMake project

In this summary you will combine CMake basics, find_package and multi-project structure. You will set up a root CMakeLists.txt with target definitions in two subdirectories (lib and app). This is the skeleton of real C++ projects.

The root file contains cmake_minimum_required, project and two add_subdirectory calls. find_package finds an external library. The application target links to the library. This structure is both modular and reusable; adding a new subdirectory needs only one add_subdirectory line.

Practice Write a complete CMake project

Write the root CMakeLists.txt. Add cmake_minimum_required(VERSION 3.20) and project(MyApp). Find the threading library with find_package(Threads REQUIRED). Include two subdirectories with add_subdirectory(lib) and add_subdirectory(app).

Starter code

main.cpp
# CMakeLists.txt (root)
# Add all commands here

Sample solution

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

Expected output

Project ready

Questions and answers

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

1 What does a multi-project CMake structure provide?

  • Faster compilation
  • Colored output
  • Less memory usage
  • Modular and reusable structure Correct answer

Explanation: The multi-project layout keeps the library separate and reusable.

2 Complete the add_subdirectory command

Question 
____(app)
Answer 
add_subdirectory(app)

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

3 Match the command to its role

Term Meaning
cmake_minimum_required Sets version
find_package Finds a library
add_subdirectory Adds a subdirectory
add_executable Defines an executable

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