For decades, C++ developers have relied on two main ways to print output:

• std::cout (from iostream)

• printf (from C)

But in C++23, we finally get something modern:

#include <print>

std::print("Hello, {}\n", name);

Yes — C++ now has a built-in, type-safe, Python-style printing function.

Let’s explore what std::print is, why it matters, and how it compares to older methods.

What Is std::print?

std::print is introduced in C++23 via the <print> header.

It is based on the formatting system from <format> (introduced in C++20), which itself was inspired by Python’s formatting style.

Example:

#include <print>

int main() {
    std::string name = "Alice";
    int age = 20;

    std::print("Name: {}, Age: {}\n", name, age);
}

Output:

Name: Alice, Age: 20

Notice:

• {} placeholders

• Automatic type safety

• Clean and readable formatting

Comparing std::print with Older Methods

Let’s compare it side by side.

---

1️⃣ std::cout (Traditional C++ Way)

std::cout << "Name: " << name << ", Age: " << age << std::endl;

Pros

• Type safe

• Fully C++

• Works everywhere

Cons

• Verbose

• Hard to format complex strings

• Slower due to stream overhead

• Chaining with << becomes messy

For example:

std::cout << std::setw(10) << std::setprecision(2) << value;

Formatting quickly becomes ugly.

---

2️⃣ printf (C Style)

printf("Name: %s, Age: %d\n", name.c_str(), age);

Pros

• Fast

• Concise formatting

• Familiar to C developers

Cons

• Not type safe

• Easy to cause undefined behavior

• Requires manual conversion (c_str())

• Format string errors are not caught at compile time

---

3️⃣ std::format (C++20)

Before std::print, we got:

#include <format>

std::string s = std::format("Name: {}, Age: {}", name, age);
std::cout << s << '\n';

Pros

• Type safe

• Modern formatting

• Very clean syntax

Cons

• Requires extra step (format → then output)

• Slightly more verbose

---

4️⃣ std::print (C++23 Modern Way)

std::print("Name: {}, Age: {}\n", name, age);

Pros

• Type safe

• Concise

• Modern formatting

• No stream chaining

• No C-style format specifiers

• Cleaner and more readable

Cons

• Requires C++23

• Compiler support still evolving

• Not yet universally available in all toolchains

MinGW on Windows doesn’t seem to support print yet! But clang and msvc works fine.

Performance Comparison (Conceptually)

In general:

• printf → Fast

• std::cout → Slower (stream overhead)

• std::print → Designed to be fast and modern

std::print avoids iostream’s heavy machinery and builds on the efficient formatting engine of <format>. For many use cases, it offers both safety and performance.

Why std::print Matters

std::print represents something bigger:

C++ is modernizing.

For years, developers complained that:

• Printing was verbose

• Formatting was awkward

• C-style formatting was unsafe

• Streams were slow and complicated

Now, we finally have a clean, safe, expressive solution built into the standard.

It brings C++ closer to languages like:

• Python (print(f"..."))

• Rust (println!)

• JavaScript (console.log())

Without sacrificing type safety.

When Should You Use std::print?

Use it if:

• You’re compiling with C++23

• Your compiler supports <print>

• You want clean formatting

• You want safer alternatives to printf

• You dislike << chaining

If you’re stuck on older standards, std::format + std::cout is the closest modern alternative.

Final Thoughts

std::print is not just another function.

It’s the long-awaited modern printing solution for C++.

• Cleaner than std::cout

• Safer than printf

• More direct than std::format

If you’re learning modern C++, it’s worth adopting early.

C++23 finally makes printing elegant. And that’s something many of us have been waiting for.