1.5 Modern Formatting: std::format and std::print

For decades, C++ developers had to choose between two printing methods: the type safe but incredibly slow and verbose stream insertion system (std::cout), or the fast but highly unsafe C style library (printf). C++20 introduced std::format, and C++23 completed it with std::print, giving us a modern, type safe, and high performance formatting library.

Let's look at format placeholders, compile time checking, and console printing optimizations.

Before looking at modern solutions, let's understand why the older approaches are flawed in production systems:

* Streams are Slow and Verbose: Writing std::cout << "User: " << name << " Age: " << age << '\n'; translates to multiple nested function calls. Furthermore, streams are stateful; if you change the printing precision for one double, that precision setting leaks globally to all future stream prints unless manually reset.

* Printf is Unsafe: C style printf is fast, but it bypasses C++ type checking. With a literal format string, GCC and Clang can warn about mismatched placeholders when -Wformat is enabled (included in -Wall, which this course recommends). Non-literal format strings often silence those warnings, and the program may print garbage or crash at runtime due to mismatched stack arguments.

C++20 introduced std::format (defined in the <format> header). It uses Python and Rust style curly brace {} placeholders, returning a formatted std::string. C++23 added std::print and std::println (defined in <print>), which write directly to the output stream without the overhead of constructing temporary string objects:

#include <iostream>
#include <format>
#include <print>
#include <string>

int main() {
    std::string name{"Bob"};
    int age{30};

    // C++20: Formats string into a variable
    std::string message = std::format("User: {} is {} years old.", name, age);
    std::cout << message << '\n';

    // C++23: Prints directly to screen with newline (zero stream overhead!)
    std::println("User: {} is {} years old.", name, age);

    // Positional arguments and floating point precision controls
    std::println("Coordinates: {1:.2f}, {0:.2f}", 4.567, 9.876);
    return 0;
}

One of the best features of modern C++ formatting is that the compiler verifies the format string at compile time. If you write a template placeholder but forget to provide matching arguments, or write incorrect formatting specifiers, compilation fails immediately, preventing runtime crashes.

std::print offers type-safe formatting and can avoid some iostream overheads. Its buffering, system calls, and performance are implementation- and destination-dependent, so treat it as a clean default rather than a universal speed guarantee.

* The Blueprint Metaphor: Using stream insertions is like assembling a water pipe segment by segment in your living room, where formatting states can leak out and ruin the carpet. Using std::print is like printing a single blueprint sheet with labeled slots. You slide your values into the slots, and the system renders the sheet in a single fast sweep.