C++20 to C++23: what changed in the language, tested with g++ -std=c++23

C++23 adds a handful of language features to C++20: a multidimensional operator[], static operator(), if consteval, auto(x), the #elifdef and #elifndef directives and "deducing this". GCC tracks them on its C++ status page and describes the C++23 support as experimental; the features arrive over several releases, so a feature that works in one GCC may be missing in an older one. Enable the standard with -std=c++23 (see __cplusplus values for how to detect it).

Language features

• Multidimensional subscript. grid[1, 0] now calls operator[](int, int). In C++20 the comma in a subscript is deprecated, and GCC warns with -Wcomma-subscript.
• static operator(). A function object with no state can have a static call operator, which avoids passing an unused this.
• if consteval. Chooses a branch depending on whether the function is being evaluated at compile time. At run time the else branch runs.
• auto(x). Makes a copy of x with decayed type, as a prvalue.
• Deducing this. An explicit object parameter, written this const S& self, replaces overloads for const and non-const objects.

Test it with g++

cat > t23.cpp <<'EOF'
struct Grid {
    int d[2][2] = {{1, 2}, {3, 4}};
    int operator[](int r, int c) const { return d[r][c]; }
};
struct Add { static int operator()(int a, int b) { return a + b; } };
constexpr int f() { if consteval { return 1; } else { return 2; } }
#ifdef FOO
#elifdef __cplusplus
#define KIND "elifdef"
#endif
int main() {
    Grid g; int x = 5;
    auto y = auto(x);
    return g[1, 0] + Add{}(2, 3) + f() + y + (KIND[0] == 'e');
}
EOF
g++ -std=c++23 -Wall t23.cpp -o t23 && echo "c++23 builds"
g++ -std=c++20 -Wall t23.cpp -o t20 2>&1 | grep "error:" | head -1

c++23 builds
t23.cpp:3:9: error: ‘int Grid::operator[](int, int) const’ must have exactly one argument

The first command compiles the file as C++23. The second compiles it as C++20 and prints the first error: the two-argument operator[] is rejected.

Upgrade checklist

1. Set -std=c++23 (or CMAKE_CXX_STANDARD 23) and read the new warnings.
2. Search for [a, b] subscripts, which change meaning.
3. Check each new feature against your compiler in the GCC status table before using it in shared code.
4. Library features (such as std::expected) are tracked separately; test them with the feature macros from <version>.
5. Compile errors about functions that no longer match are described in no matching function for call.

FAQ