C++ Ecosystem and Tooling

Overview

C++ has a mature but historically fragmented toolchain: CMake is the de facto build system (~83% market share), vcpkg/Conan are the package managers, GoogleTest/Catch2 the test frameworks, and libraries like Boost, Eigen, fmt, and Qt fill the standard library’s gaps. This page is the practical map of the ecosystem for interviews and real projects. See C++ Overview for the language.

Build Systems: CMake is the Standard

cmake_minimum_required(VERSION 3.20)
project(myapp CXX)

set(CMAKE_CXX_STANDARD 20)

add_executable(myapp src/main.cpp)
target_link_libraries(myapp PRIVATE fmt::fmt)

Best practice: CMake + Ninja as the default; use CMake Presets for reproducible configurations and FetchContent for small dependencies.

Package Managers: vcpkg vs Conan

Choose vcpkg for simplicity and Windows/Visual Studio; Conan for cross-platform flexibility, binary caching at scale, and fine-grained versioning. Use manifest + lockfiles in both for reproducible builds.

Testing: GoogleTest vs Catch2

// GoogleTest
TEST(MathTest, Add) {
    EXPECT_EQ(add(2, 3), 5);
}

// Catch2
TEST_CASE("add works") {
    REQUIRE(add(2, 3) == 5);
}

Both integrate with CTest (add_test in CMake). Doctest is a lighter third option.

The Key Libraries

fmt example

#include <fmt/core.h>
int main() {
    fmt::print("Hello, {}! You have {} messages.\n", "world", 42);
}

fmt::format is type-safe (compile-time format string checking), fast, and is the reference implementation of C++20’s std::format.

Eigen example

#include <Eigen/Dense>
Eigen::MatrixXd m(2, 2);
m << 1, 2, 3, 4;
auto v = m * Eigen::Vector2d(1, 1);   // vectorized, expression templates

Analysis and Debugging Tools

Sanitizers are the single most valuable addition for finding the bugs the language lets you write (use-after-free, leaks, UB).

Interview Questions

Q: Why is CMake the de facto standard build system?

CMake is a meta build system that generates platform-native build files (Ninja/Make/Visual Studio/Xcode) from one CMakeLists.txt, making cross-platform builds reproducible. It has the largest ecosystem (most libraries ship CMake support), integrates with package managers (vcpkg/Conan) and IDEs, and cmake --build is a uniform interface. ~83% of C++ projects use it.

Q: vcpkg vs Conan — which would you choose?

vcpkg for simplicity, quick start, and tight Windows/Visual Studio integration (toolchain-file transparency). Conan for cross-platform flexibility, fine-grained versioning with lockfiles, binary caching at scale, and private package registries. Both integrate with CMake; use manifest + lockfiles for reproducibility.

Q: What do sanitizers catch and why are they essential in C++?

ASan catches memory errors (use-after-free, heap overflow, leaks), UBSan catches undefined behavior, TSan data races. Compile with -fsanitize=address,undefined in tests/CI to catch the bug classes C++ allows (raw pointers, manual memory) before they reach production — where they manifest as hard-to-debug crashes and security holes.

Q: How does std::format/fmt differ from printf?

printf is type-unsafe (format string vs arguments can mismatch → UB). std::format (from the fmt library) checks the format string at compile time, is type-safe, and supports user-defined types — with comparable or better performance. It’s the modern replacement for printf-style formatting.

Q: What would you use Boost for today?

Boost is the “second standard library”: asio (async I/O), graph, random, spirit (parsers), multiprecision, etc. Many of its components were adopted into the standard library (shared_ptr, filesystem, regex, chrono), so modern C++ often needs Boost only for the parts not yet standardized — asio (networking) being the main one until C++26 networking matures. Use Boost where it fills a real gap; prefer the standard library first.

References

• CMake documentation — https://cmake.org/documentation/
• vcpkg — https://vcpkg.io/
• Conan — https://conan.io/
• GoogleTest — https://google.github.io/googletest/
• Catch2 — https://github.com/catchorg/Catch2
• fmt — https://fmt.dev/
• Eigen — https://eigen.tuxfamily.org/
• Boost — https://www.boost.org/
• Qt — https://www.qt.io/

Related Topics

• C++ Overview — the language
• Memory Model — why sanitizers matter
• Move Semantics — modern C++ idioms
• Compilation — the C compilation pipeline (shared with C++)
• CMake and Builds — build tooling