char8_t

char8_t — отдельный фундаментальный тип для представления одного UTF-8 code unit (одного байта UTF-8 последовательности), отличный от char. Строковые литералы u8"text" начиная с C++20 имеют тип const char8_t* — в C++17 и раньше тот же литерал имел тип const char*. Тип не меняет представление в памяти (это всё ещё один байт), он меняет то, что о содержимом байта знает система типов компилятора.char8_t is a distinct fundamental type representing a single UTF-8 code unit (one byte of a UTF-8 sequence), separate from char. Starting with C++20, u8"text" string literals have type const char8_t* — in C++17 and earlier, the same literal had type const char*. The type doesn't change the in-memory representation (it's still one byte); it changes what the compiler's type system knows about the byte's contents.

const char* s1 = "plain string";         // платформенная кодировка// platform encoding
const char* s2 = u8"utf-8 string";       // тот же самый тип const char*!// the very same type const char*!

void f(const char*);   // одна перегрузка — нельзя различить// one overload — can't be distinguished
// f(s1) и f(s2) неотличимы для компилятора по типу// f(s1) and f(s2) are indistinguishable to the compiler by type

const char* s1 = "plain string";         // const char*// const char*
const char8_t* s2 = u8"utf-8 string";       // const char8_t* — другой тип// const char8_t* — a different type

void f(const char*);
void f(const char8_t*);   // теперь возможна отдельная перегрузка// now a separate overload is possible

char8_t — отдельный фундаментальный тип (не typedef и не alias для char или unsigned char), с теми же размером (1 байт) и представлением, что и unsigned char, но отдельный для целей перегрузки, шаблонов и std::is_same. Это тот же подход, что уже применялся к char16_t/char32_t в C++11 для UTF-16/UTF-32 — char8_t закрывает симметричный пробел для UTF-8, который до этого обходился обычным char по историческим причинам (UTF-8 литералы появились в C++11, но получили собственный тип только в C++20).char8_t is a distinct fundamental type (not a typedef or alias for char or unsigned char), with the same size (1 byte) and representation as unsigned char, but distinct for the purposes of overloading, templates, and std::is_same. This mirrors the approach already taken for char16_t/char32_t in C++11 for UTF-16/UTF-32 — char8_t fills the symmetric gap for UTF-8, which until then made do with plain char for historical reasons (UTF-8 literals appeared in C++11 but only got their own type in C++20).

static_assert(!std::is_same_v<char8_t, char>);        // разные типы// different types
static_assert(sizeof(char8_t) == 1);                 // тот же размер// same size

const char8_t* utf8 = u8"hello";
std::size_t len = std::char_traits<char8_t>::length(utf8);

// взаимодействие со старым API, ожидающим const char*:// interop with older APIs expecting const char*:
void legacy_api(const char* s);
legacy_api(reinterpret_cast<const char*>(utf8));   // явный cast обязателен// an explicit cast is mandatory

Ключевой сценарий, невозможный до char8_t, — раздельные перегрузки одной функции для "строки в неизвестной/локальной кодировке" и для "заведомо UTF-8 строки". До C++20 оба вызова разрешались бы в одну и ту же перегрузку const char*, потому что оба литерала имели один и тот же тип:The key scenario impossible before char8_t is a pair of separate overloads of the same function — one for "a string in an unknown/local encoding" and one for "a known-UTF-8 string." Before C++20 both calls would resolve to the same const char* overload, because both literals had the exact same type:

void log_message(const char* s) {
    std::fputs(s, stderr);   // кодировка неизвестна — просто байты как есть// encoding unknown — bytes passed through as-is
}
void log_message(const char8_t* s) {
    log_utf8_to_console(s);   // заведомо UTF-8 — можно применить UTF-8-специфичную обработку// known UTF-8 — safe to apply UTF-8-specific handling
}

log_message("plain text");      // выбирает перегрузку const char*// picks the const char* overload
log_message(u8"hello");       // выбирает перегрузку const char8_t*// picks the const char8_t* overload

• cppreference — char8_t
• WG21 P0482 — char8_t: A type for UTF-8 characters and strings