Строковый литерал

Синтаксис

Пояснение

В перечисленных выше типах N — это количество кодовых единиц, которое определяется ниже.

Обычные и UTF-8(начиная с C++11) строковые литералы совместно называются узкими строковыми литералами.

В результате вычисления строкового литерала создаётся объект строкового литерала со статической длительностью хранения. Не специфицировано, хранятся ли все строковые литералы в неперекрывающихся объектах и создают ли последовательные вычисления строкового литерала один и тот же или разные объекты.

Попытка изменить объект строкового литерала приводит к неопределённому поведению.

bool b = "bar" == 3 + "foobar"; // can be true or false, unspecified

const char* pc = "Hello";
char* p = const_cast<char*>(pc);
p[0] = 'M'; // undefined behavior

// OK: contains one backslash,
// equivalent to "\\"
R"(\)";

// OK: contains four \n pairs,
// equivalent to "\\n\\n\\n\\n"
R"(\n\n\n\n)";

// OK: contains one close-parenthesis, two double-quotes and one open-parenthesis,
// equivalent to ")\"\"("
R"-()""()-";

// OK: equivalent to "\n)\\\na\"\"\n"
R"a(
)\
a""
)a";

// OK: equivalent to "x = \"\"\\y\"\""
R"(x = ""\y"")";

// R"<<(-_-)>>"; // Error: begin and end delimiters do not match
// R"-()-"-()-"; // Error: )-" appears in the middle and terminates the literal

Инициализация

Объекты строковых литералов инициализируются последовательностью значений кодовых единиц, соответствующих последовательности символов s-char в строковом литерале и символов r-char(начиная с C++11), а также завершающим нулевым символом (U+0000), в следующем порядке:

• Если v не превышает диапазон представимых значений T, управляющая последовательность добавляет одну кодовую единицу со значением v.
• В противном случае, если строковый литерал имеет синтаксическую форму (1) или (3) и(начиная с C++11) v не превышает диапазон представимых значений соответствующего беззнакового типа для базового типа T, управляющая последовательность добавляет одну кодовую единицу с уникальным значением типа T, сравнимым с v по модулю 2^S, где S — ширина T.
• В противном случае программа некорректна.

Конкатенация

Соседние строковые литералы объединяются на этапе трансляции 6 (после препроцессирования):

• Если оба строковых литерала имеют один и тот же вид, объединённый строковый литерал также имеет этот вид.

"Hello, " "world!" // at phase 6, the 2 string literals form "Hello, world!"

L"Δx = %" PRId16   // at phase 4, PRId16 expands to "d"
                   // at phase 6, L"Δx = %" and "d" form L"Δx = %d"

Невычисляемые строки

В следующих контекстах ожидается строковый литерал, но он не вычисляется:

• спецификация языковой связи

Примечания

Строковые литералы можно использовать для инициализации символьных массивов. Если массив инициализируется так: char str[] = "foo";, str будет содержать копию строки "foo".

Строковый литерал не обязательно представляет собой последовательность символов, завершённую нулевым символом: если строковый литерал содержит встроенные нулевые символы, он представляет массив, содержащий более одной строки.

const char* p = "abc\0def"; // std::strlen(p) == 3, but the array has size 8

Если после шестнадцатеричной управляющей последовательности в строковом литерале следует допустимая шестнадцатеричная цифра, компиляция завершится ошибкой из-за недопустимой управляющей последовательности. Обойти это можно с помощью конкатенации строк:

//const char* p = "\xfff"; // error: hexadecimal escape sequence out of range
const char* p = "\xff""f"; // OK: the literal is const char[3] holding {'\xff','f','\0'}

Пример

#include <iostream>

// array1 and array2 contains the same values:
char array1[] = "Foo" "bar";
char array2[] = {'F', 'o', 'o', 'b', 'a', 'r', '\0'};

const char* s1 = R"foo(
Hello
  World
)foo";
// same as
const char* s2 = "\nHello\n  World\n";
// same as
const char* s3 = "\n"
                 "Hello\n"
                 "  World\n";

const wchar_t* s4 = L"ABC" L"DEF"; // OK, same as
const wchar_t* s5 = L"ABCDEF";
const char32_t* s6 = U"GHI" "JKL"; // OK, same as
const char32_t* s7 = U"GHIJKL";
const char16_t* s9 = "MN" u"OP" "QR"; // OK, same as
const char16_t* sA = u"MNOPQR";

// const auto* sB = u"Mixed" U"Types";
        // before C++23 may or may not be supported by
        // the implementation; ill-formed since C++23

const wchar_t* sC = LR"--(STUV)--"; // OK, raw string literal

int main()
{
    std::cout << array1 << ' ' << array2 << '\n'
              << s1 << s2 << s3 << std::endl;
    std::wcout << s4 << ' ' << s5 << ' ' << sC
               << std::endl;
}

Foobar Foobar

Hello
  World

Hello
  World

Hello
  World

ABCDEF ABCDEF STUV

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены задним числом к ранее опубликованным стандартам C++.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2024):
• 5.13.5 Строковые литералы [lex.string]
• Стандарт C++20 (ISO/IEC 14882:2020):
• 5.13.5 Строковые литералы [lex.string]
• Стандарт C++17 (ISO/IEC 14882:2017):
• 5.13.5 Строковые литералы [lex.string]
• Стандарт C++14 (ISO/IEC 14882:2014):
• 2.14.5 Строковые литералы [lex.string]
• Стандарт C++11 (ISO/IEC 14882:2011):
• 2.14.5 Строковые литералы [lex.string]
• Стандарт C++03 (ISO/IEC 14882:2003):
• 2.13.4 Строковые литералы [lex.string]
• Стандарт C++98 (ISO/IEC 14882:1998):
• 2.13.4 Строковые литералы [lex.string]

См. также