C++23 marks a massive leap forward in everyday ergonomics, safer error propagation, and compile-time tooling. Moving beyond the foundational paradigms introduced in C++20, this standard focuses heavily on making codebases cleaner, faster, and more expressive.
Here are the 15 essential features every C++ developer should leverage in modern projects.
1. std::print and std::println
Formatted printing is finally a native, type-safe one-liner in the standard library. No more juggling legacy printf specifiers or clunky iostreams.
#include <print>
int main() {
std::println("Hello, {}! Codebase health is: {:.1f}%", "C++23", 98.5);
}- Why it matters: compile-time-checked format strings, superior throughput, and cleaner logging across hot paths.
2. std::expected
Brings typed errors-as-values to C++, allowing functions to return either a valid result or an unexpected error payload without throwing exceptions.
#include <expected>
#include <string>
std::expected<int, std::string> parseConfig(const std::string& path) {
if (path.empty()) return std::unexpected("Invalid path");
return 42; // parsed value
}- Why it matters: exceptional for low-latency modules, plugin interfaces, and ABI boundaries where exceptions introduce overhead or safety concerns.
3. Deducing this (Explicit Object Parameters)
Solves a decade-long pain point for library authors by allowing member functions to deduce their own value category and const-ness.
struct Builder {
std::string buffer;
auto append(this auto&& self, std::string_view text) {
self.buffer.append(text);
return std::forward<decltype(self)>(self); // Fluent chaining
}
};- Why it matters: eliminates boilerplate duplicate overloads for const, non-const, lvalue, and rvalue member functions.
4. Ranges Grow Up: std::views::zip, chunk, and slide
C++20 introduced ranges, but C++23 supercharges them with multi-sequence adaptors.
#include <ranges>
#include <vector>
#include <iostream>
std::vector<int> keys = {1, 2, 3};
std::vector<std::string> values = {"one", "two", "three"};
auto zipped = std::views::zip(keys, values);- Why it matters: replaces fragile index-based loops with correct-by-construction data pipelines.
5. std::ranges::to
A seamless way to convert any range view directly back into a standard container.
#include <ranges>
#include <vector>
#include <set>
std::vector<int> v = {1, 2, 2, 3};
auto s = v | std::views::filter([](int x){ return x > 1; })
| std::ranges::to<std::set>();- Why it matters: ends lazy evaluation pipelines cleanly without manual container initialization boilerplate.
6. std::stacktrace
Standardized portable stack traces right out of the box.
#include <stacktrace>
#include <print>
void debugLog() {
std::println("Current execution path:\n{}", std::stacktrace::current());
}- Why it matters: drastically accelerates incident triage and error reporting without relying on platform-specific APIs (DBGHELP / backtrace).
7. Monadic Operations for std::optional
std::optional gains and_then, transform, and or_else, matching the expressive power of std::expected.
#include <optional>
std::optional<std::string> getUsername(int id);
auto length = getUsername(10)
.transform([](const std::string& name) { return name.length(); });- Why it matters: completely removes nested if (opt.has_value()) pyramid hell.
8. if consteval
Distinguishes compile-time evaluation from runtime execution cleanly.
constexpr int compute(int x) {
if consteval {
return fastCompileTimeAlgorithm(x);
} else {
return optimizedRuntimeSIMD(x);
}
}- Why it matters: simplifies writing dual-path functions that optimize for both compile-time evaluation and runtime performance.
9. auto(x) and auto{x} (Decaying Expressions)
Creates a temporary, decayed copy of an expression inline.
auto process = [ptr = auto(*expensiveRef)]() {
// captures a decayed copy safely
};- Why it matters: prevents dangling references in lambdas and async task boundaries.
10. std::generator (Coroutines Made Practical)
Provides a standard asynchronous/lazy generator type for C++ coroutines.
#include <generator>
std::generator<int> fibonacci() {
int a = 0, b = 1;
while (true) {
co_yield a;
auto next = a + b;
a = b;
b = next;
}
}- Why it matters: simplifies stream processing and sequence generation without heavy custom boilerplate code.
11. std::byteswap
A portable standard utility for swapping byte ordering.
#include <bit>
uint32_t val = 0x12345678;
uint32_t swapped = std::byteswap(val); // 0x78563412- Why it matters: vital for network protocols, binary file parsing, and cross-platform low-level serialization.
12. std::to_underlying
Converts an enumeration type directly to its underlying type safely.
enum class Status : uint8_t { Ok = 0, Error = 1 };
auto val = std::to_underlying(Status::Error); // returns uint8_t(1)- Why it matters: replaces clumsy explicit static casts (static_cast<std::underlying_type_t<Status>>(val)) with clean intent.
13. std::string::contains and std::string_view::contains
Directly checks for substring or character existence.
#include <string>
std::string url = "https://cppdepend.com";
if (url.contains("https")) {
// Secure URL handled cleanly
}- Why it matters: eliminates the verbose str.find(...) != std::string::npos check idiom.
14. Multidimensional std::mdspan
A non-owning multidimensional view over contiguous data blocks.
#include <mdspan>
#include <vector>
std::vector<double> data(12);
std::mdspan matrix(data.data(), 3, 4); // 3x4 grid view
matrix[1, 2] = 5.0; // Zero allocation overhead- Why it matters: perfect for math-heavy processing, image manipulation, and game engines without dictating memory allocation layout.
15. std::unreachable (Explicit Lifetime Management)
Allows developers to mark unreachable branches to help compilers optimize aggressively.
#include <utility>
void handleColor(Color c) {
switch(c) {
case Color::Red: break;
case Color::Blue: break;
default: std::unreachable(); // Tells optimizer this path is impossible
}
}- Why it matters: unlocks advanced compiler branch optimization and eliminates dead runtime check code paths.
Keep Your Modernized Codebase Healthy
Adopting C++23 features modernizes your codebase — but modernization at scale needs guardrails. Which files still use printf-style logging? Did that new std::expected boundary introduce an architectural dependency you didn’t intend? Is cyclomatic complexity creeping up in your new coroutine code?
CppDepend answers these questions automatically: query your codebase with CQLinq to find every legacy pattern worth migrating, track technical debt as you modernize, and visualize the impact of every change in 3D with Smart Code City — as explored in our previous articles: