Строковая литерал

Синтаксис

Объяснение

В типах, перечисленных в таблице выше, 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, то escape-последовательность вносит одну кодовую единицу со значением v.
• В противном случае, если строковая литерал имеет синтаксис (1) или (3), и(с C++11) v не превышает диапазон представимых значений соответствующего беззнакового типа для базового типа T, то escape-последовательность вносит одну кодовую единицу с уникальным значением типа T, которое совпадает с \(v \bmod 2^S\)v mod 2^S, где S — ширина T.
• В противном случае программа неверна.

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

Строковые литералы, расположенные рядом, конкатенируются на фазе 6 трансляции (после препроцессора). То есть, "Hello," " world!" даёт (единую) строку "Hello, world!". Если две строки имеют одинаковый префикс кодировки (или ни у одной нет префикса), то результирующая строка будет иметь тот же префикс кодировки (или не будет иметь префикса).

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

Неоцениваемые строки

Следующие контексты ожидают строковый литерал, но не оценивают его:

• Спецификация связывания языков
• static_assert (с C++11)
• Имя оператора литерала (с C++11)
• [[deprecated]] (с C++14)
• [[nodiscard]] (с C++20)

Примечания

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

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

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

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

//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>
 
char array1[] = "Foo" "bar";
// same as
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++.

1. P1854R4 был принят как отчёт об ошибке позже, отменяя это решение.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2023):
• 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]

См. также