C++ 23: Những Tính Năng Mới Mỗi Lập Trình Viên Cần Biết

Tiêu chuẩn C++ 23 (ISO/IEC 14882:2024) là một bước tiến quan trọng trong sự phát triển của ngôn ngữ lập trình hệ thống mạnh mẽ nhất thế giới. Dù không mang tính cách mạng như C++ 11 hay C++ 20, C++ 23 tập trung vào việc hoàn thiện, loại bỏ các rắc rối hằng ngày và thêm các công cụ tiện lợi giúp code an toàn, dễ đọc và hiệu suất hơn. Bài viết này tổng hợp những thay đổi quan trọng nhất mà các lập trình viên C++ cần nắm bắt.

Deduction This (P0847) – Loại Bỏ Viết Trùng Lặp

Một trong những tính năng được mong đợi nhất là deduction this, cho phép hàm thành viên suy diễn đối tượng this một cách rõ ràng. Trước đây, để viết một hàm thành viên hoạt động cả cho đối tượng const, non-const, lvalue và rvalue, bạn cần nạp chồng 4 phiên bản. Với C++ 23, một phiên bản duy nhất là đủ:

template 
auto& get(Self&& self) { return self.value_; }

Điều này giảm đáng kể lượng code boilerplate và loại bỏ khả năng sai sót khi duy trì nhiều overload.

Static operator[] và operator() (P2128)

C++ 23 cho phép định nghĩa operator[] và operator() là static hoặc non-static. Điều này đặc biệt hữu ích cho các kiểu như mdspan hay container đa chiều, nơi việc truy cập chỉ mục có thể phụ thuộc vào đối tượng hoặc không.

struct Matrix {
    static constexpr int stride = 4;
    int data[16];
    
    // Truy cập theo chỉ mục (static - không cần đối tượng)
    static auto at(int row, int col) -> int&;
    
    // Hoặc theo đối tượng
    auto operator[](int row, int col) -> int&;
};

std::expected – Xử Lý Lỗi Hiện Đại

Thư viện mang lại kiểu std::expected – một sum type đại diện cho kết quả thành công (giá trị T) hoặc lỗi (giá trị E). Đây là công cụ mạnh mẽ cho xử lý lỗi không dùng exception, phù hợp cho hệ thống nhúng, real-time và code hiệu suất cao.

#include 
#include 

std::expected readFile(const char* path) {
    // Nếu thành công
    return "nội dung file";
    // Nếu lỗi
    return std::unexpected(404);
}

auto result = readFile("config.txt");
if (result) {
    // dùng *result
} else {
    // xử lý result.error()
}

std::print và std::println – Format Output Chuẩn

Thay thế std::cout phức tạp và printf không an toàn, C++ 23 đưa ra std::print và std::println trong với cú pháp format hiện đại:

#include 

std::println("Xin chào {}! Năm nay là {}.", "C++", 2024);
std::print("Kết quả: {:.2f}n", 3.14159);

Hiệu suất tốt hơn iostream, an toàn kiểu, và hỗ trợ Unicode đầy đủ.

Ranges Algorithms Mới: views::slide, views::chunk, views::join_with

Thư viện Ranges được mở rộng thêm các adaptor mạnh mẽ:

• views::slide(n): tạo cửa sổ trượt kích thước n
• views::chunk(n): chia range thành các chunk kích thước n
• views::chunk_by(pred): chia dựa trên predicate
• views::join_with(delim): nối các range với phân cách

#include 
#include 
#include 

std::vector v = {1, 2, 3, 4, 5, 6};
for (auto chunk : v | std::views::chunk(2)) {
    for (int x : chunk) std::print("{} ", x);
    std::println("");
}
// Output: 1 2
//         3 4
//         5 6

std::optional::and_then, or_else, transform

std::optional nhận được các phương thức monadic giúp chuỗi xử lý an toàn hơn:

auto result = getOptionalValue()
    .and_then([](auto x) { return process(x); })
    .transform([](auto x) { return x * 2; })
    .or_else([] { return fallbackValue(); });

Giảm lồng code if và làm luồng dữ liệu rõ ràng hơn.

Relaxed constexpr – constexpr Hơn, Hạn Chế Ít Hơn

C++ 23 cho phép nhiều cấu trúc hơn trong constexpr:

• Định nghĩa biến cục bộ không khởi tạo (chỉ tuyên bố)
• Sử dụng goto và switch trong hàm constexpr
• Truy cập thành viên union đang hoạt động
• Sử dụng std::vector, std::string trong constexpr (thông qua allocator)

Điều này đẩy việc tính toán lúc compile-time xa hơn, giảm tải runtime.

std::mdspan – Multidimensional Array View

std::mdspan trong cung cấp view không sở hữu (non-owning) cho mảng đa chiều, cho phép truy cập dữ liệu liên tục như matrix/tensor mà không copy dữ liệu. Đây là nền tảng cho tính toán khoa học, ML và HPC hiệu suất cao.

#include 
#include 

std::vector data(100);
auto matrix = std::mdspan<double, std::extents>(data.data());
matrix[3][4] = 1.5; // truy cập như mảng 2D

Stacktrace – Gỡ Lỗi Dễ Dàng Hơn

Thư viện cung cấp std::stacktrace để thu thập và in stack trace lúc runtime mà không cần debugger:

#include 
#include 

void foo() { std::println("{}", std::stacktrace::current()); }

int main() { foo(); }

Cực kỳ hữu ích cho logging, crash reporting và chẩn đoán production.

Các Thay Đổi Khác Cần Chú Ý

• Labels at end of compound statements (P2324): Cho phép label sau khối code, hữu ích cho vòng lặp lồng nhau
• constexpr std::format (P2508): Format string lúc compile-time
• std::to_underlying (P1682): Chuyển enum sang kiểu nền tảng an toàn
• std::is_constant_evaluated() deprecated: Thay bằng if consteval
• Attributes [[assume]], [[likely]], [[unlikely]]: Hỗ trợ tối ưu hóa trình biên dịch

Hỗ Trợ Trình Biên Dịch

Hiện tại, GCC 13+, Clang 16+, và MSVC 19.38+ (Visual Studio 2022 17.6+) đã hỗ trợ phần lớn tính năng C++ 23. Bật cờ -std=c++23 (GCC/Clang) hoặc /std:c++23 (MSVC) để sử dụng.

Kết luận: C++ 23 không thay đổi cách bạn tư duy về C++ như C++ 11/20, nhưng nó giải quyết hàng chục vấn đề thực tế hàng ngày – từ boilerplate, xử lý lỗi, đến debug và hiệu suất. Việc áp dụng dần các tính năng này sẽ giúp code C++ của bạn hiện đại, an toàn và dễ bảo trì hơn.

Nguồn tham khảo:

• ISO/IEC 14882:2024 Programming Languages — C++ (Final Draft)
• C++23 standard library features — cppreference.com
• Deducing this (P0847R7)