Condividi tramite

Valori letterali stringa e carattere (C++)

  • Articolo

C++ supporta diversi tipi di stringa e di carattere e permette di esprimere i valori letterali di ogni tipo. Nel codice sorgente, si esprime il contenuto dei valori letterali carattere e stringa usando un set di caratteri. I nomi di caratteri universali e i caratteri di escape consentono di esprimere qualsiasi stringa usando solo il set di caratteri di origine di base. Un valore letterale stringa non elaborata permette di evitare l'uso di caratteri di escape e può essere usato per esprimere tutti i tipi di valori letterali stringa. È anche possibile creare std::string valori letterali senza dover eseguire passaggi di costruzione o conversione aggiuntivi.

#include <string>
using namespace std::string_literals; // enables s-suffix for std::string literals

int main()
{
    // Character literals
    auto c0 =   'A'; // char
    auto c1 = u8'A'; // char
    auto c2 =  L'A'; // wchar_t
    auto c3 =  u'A'; // char16_t
    auto c4 =  U'A'; // char32_t

    // Multicharacter literals
    auto m0 = 'abcd'; // int, value 0x61626364

    // String literals
    auto s0 =   "hello"; // const char*
    auto s1 = u8"hello"; // const char* before C++20, encoded as UTF-8,
                         // const char8_t* in C++20
    auto s2 =  L"hello"; // const wchar_t*
    auto s3 =  u"hello"; // const char16_t*, encoded as UTF-16
    auto s4 =  U"hello"; // const char32_t*, encoded as UTF-32

    // Raw string literals containing unescaped \ and "
    auto R0 =   R"("Hello \ world")"; // const char*
    auto R1 = u8R"("Hello \ world")"; // const char* before C++20, encoded as UTF-8,
                                      // const char8_t* in C++20
    auto R2 =  LR"("Hello \ world")"; // const wchar_t*
    auto R3 =  uR"("Hello \ world")"; // const char16_t*, encoded as UTF-16
    auto R4 =  UR"("Hello \ world")"; // const char32_t*, encoded as UTF-32

    // Combining string literals with standard s-suffix
    auto S0 =   "hello"s; // std::string
    auto S1 = u8"hello"s; // std::string before C++20, std::u8string in C++20
    auto S2 =  L"hello"s; // std::wstring
    auto S3 =  u"hello"s; // std::u16string
    auto S4 =  U"hello"s; // std::u32string

    // Combining raw string literals with standard s-suffix
    auto S5 =   R"("Hello \ world")"s; // std::string from a raw const char*
    auto S6 = u8R"("Hello \ world")"s; // std::string from a raw const char* before C++20, encoded as UTF-8,
                                       // std::u8string in C++20
    auto S7 =  LR"("Hello \ world")"s; // std::wstring from a raw const wchar_t*
    auto S8 =  uR"("Hello \ world")"s; // std::u16string from a raw const char16_t*, encoded as UTF-16
    auto S9 =  UR"("Hello \ world")"s; // std::u32string from a raw const char32_t*, encoded as UTF-32
}

I valori letterali stringa non possono avere prefissi o u8, Lu, e U per indicare caratteri narrow (byte singolo o multi byte), UTF-8, carattere wide (UCS-2 o UTF-16), codifiche UTF-16 e UTF-32, rispettivamente. Un valore letterale stringa non elaborato può avere Rprefissi , u8RLR, uR, e UR per gli equivalenti di versione non elaborata di queste codifiche. Per creare valori temporanei o statici std::string , è possibile usare valori letterali stringa o valori letterali stringa non elaborati con un s suffisso. Per altre informazioni, vedere la sezione Valori letterali stringa di seguito. Per altre informazioni sul set di caratteri di origine di base, sui nomi di caratteri universali e sull'uso di caratteri delle tabelle codici estese nel codice sorgente, vedere Set di caratteri.

Valori letterali carattere

Un valore letterale carattere è costituito da un carattere costante. È rappresentato dal carattere racchiuso tra virgolette singole. Esistono cinque tipi di valori letterali carattere:

  • Valori letterali carattere ordinari di tipo char, ad esempio 'a'

  • Valori letterali carattere UTF-8 di tipo char (char8_t in C++20), ad esempio u8'a'

  • Valori letterali carattere wide di tipo wchar_t, ad esempio L'a'

  • Valori letterali carattere UTF-16 di tipo char16_t, ad esempio u'a'

  • Valori letterali carattere UTF-32 di tipo char32_t, ad esempio U'a'

Il carattere utilizzato per un valore letterale carattere può essere qualsiasi carattere, ad eccezione della barra rovesciata dei caratteri riservati (\), virgolette singole (') o nuova riga. I caratteri riservati possono essere specificati con una sequenza di escape. È possibile specificare i caratteri usando nomi di caratteri universali, a condizione che le dimensioni del tipo siano sufficienti a contenere il carattere.

Codifica

I valori letterali carattere vengono codificati in modo diverso in base al prefisso.

  • Un valore letterale carattere senza prefisso è un valore letterale carattere ordinario. Il valore di un valore letterale carattere ordinario contenente un singolo carattere, una sequenza di escape o un nome di carattere universale che può essere rappresentato nel set di caratteri di esecuzione ha un valore uguale al valore numerico della relativa codifica nel set di caratteri di esecuzione. Un valore letterale carattere comune che contiene più di un carattere, una sequenza di escape o un nome di carattere universale è un valore letterale multicaracter. Un valore letterale multicaracter o un valore letterale carattere ordinario che non può essere rappresentato nel set di caratteri di esecuzione ha tipo inte il relativo valore è definito dall'implementazione. Per MSVC, vedere la sezione specifica di Microsoft di seguito.

  • Un valore letterale carattere che inizia con il L prefisso è un valore letterale carattere wide. Il valore di un valore letterale a caratteri wide contenente un singolo carattere, una sequenza di escape o un nome di carattere universale ha un valore uguale al valore numerico della relativa codifica nel set di caratteri wide di esecuzione, a meno che il valore letterale carattere non abbia alcuna rappresentazione nel set di caratteri wide di esecuzione, nel qual caso il valore è definito dall'implementazione. Il valore di un valore letterale di caratteri wide contenente più caratteri, sequenze di escape o nomi di caratteri universali è definito dall'implementazione. Per MSVC, vedere la sezione specifica di Microsoft di seguito.

  • Un valore letterale carattere che inizia con il u8 prefisso è un valore letterale carattere UTF-8. Il valore di un valore letterale carattere UTF-8 contenente un singolo carattere, una sequenza di escape o un nome di carattere universale ha un valore uguale al valore del punto di codice ISO 10646 se può essere rappresentato da una singola unità di codice UTF-8 (corrispondente al blocco Unicode C0 Controls e Basic Latin Unicode). Se il valore non può essere rappresentato da una singola unità di codice UTF-8, il programma non è formato correttamente. Un valore letterale carattere UTF-8 contenente più di un carattere, una sequenza di escape o un nome di carattere universale non è valido.

  • Un valore letterale carattere che inizia con il u prefisso è un valore letterale carattere UTF-16. Il valore di un valore letterale carattere UTF-16 contenente un singolo carattere, una sequenza di escape o un nome di carattere universale ha un valore uguale al valore del punto di codice ISO 10646, se può essere rappresentato da una singola unità di codice UTF-16 (corrispondente al piano multi-linguale di base). Se il valore non può essere rappresentato da una singola unità di codice UTF-16, il programma non è formato correttamente. Un valore letterale carattere UTF-16 contenente più caratteri, sequenza di escape o nome carattere universale non è formato correttamente.

  • Un valore letterale carattere che inizia con il U prefisso è un valore letterale carattere UTF-32. Il valore di un valore letterale carattere UTF-32 contenente un singolo carattere, una sequenza di escape o un nome carattere universale ha un valore uguale al valore del punto di codice ISO 10646. Un valore letterale carattere UTF-32 contenente più caratteri, sequenza di escape o nome carattere universale non è formato correttamente.

Sequenze di escape

Esistono tre tipi di sequenze di escape: semplici, ottali ed esadecimali. Le sequenze di escape possono essere uno dei valori seguenti:

Valore Sequenza di escape
carattere di nuova riga \n
barra rovesciata \\
tabulazione orizzontale \t
punto interrogativo ? O\?
tabulazione verticale \v
virgoletta singola \'
BACKSPACE \b
virgoletta doppia \"
ritorno a capo \r
carattere null \0
avanzamento carta \f
ottale \ooo
avviso (campana) \a
esadecimale \xhhh

Una sequenza di escape ottale è una barra rovesciata seguita da una sequenza da una a tre cifre ottali. Una sequenza di escape ottale termina al primo carattere che non è una cifra ottale, se rilevata prima della terza cifra. Il valore ottale più alto possibile è \377.

Una sequenza di escape esadecimale è una barra rovesciata seguita dal carattere x, seguita da una sequenza di una o più cifre esadecimali. Gli zero iniziali vengono ignorati. In un valore letterale carattere normale o con prefisso u8, il valore esadecimale più alto è 0xFF. In un valore letterale carattere wide con prefisso L o u il valore esadecimale più elevato è 0xFFFF. In un valore letterale carattere wide con prefisso U il valore esadecimale più elevato è 0xFFFFFFFF.

Questo codice di esempio mostra alcuni esempi di caratteri di escape che usano valori letterali carattere normale. La stessa sintassi della sequenza di escape è valida per gli altri tipi letterali carattere.

#include <iostream>
using namespace std;

int main() {
    char newline = '\n';
    char tab = '\t';
    char backspace = '\b';
    char backslash = '\\';
    char nullChar = '\0';

    cout << "Newline character: " << newline << "ending" << endl;
    cout << "Tab character: " << tab << "ending" << endl;
    cout << "Backspace character: " << backspace << "ending" << endl;
    cout << "Backslash character: " << backslash << "ending" << endl;
    cout << "Null character: " << nullChar << "ending" << endl;
}
/* Output:
Newline character:
ending
Tab character:  ending
Backspace character:ending
Backslash character: \ending
Null character:  ending
*/

Il carattere barra rovesciata (\) è un carattere di continuazione riga quando viene posizionato alla fine di una riga. Se si vuole che un carattere barra rovesciata venga visualizzato come un valore letterale carattere, è necessario digitare due barre rovesciate di seguito in una riga (\\). Per altre informazioni sul carattere di continuazione di riga, vedere Phases of Translation.

Specifico di Microsoft

Per creare un valore da un valore letterale multicaracter stretto, il compilatore converte il carattere o la sequenza di caratteri tra virgolette singole in valori a 8 bit all'interno di un intero a 32 bit. Più caratteri nel valore letterale carattere riempiono i byte corrispondenti secondo le necessità, dal più significativo al meno significativo. Il compilatore converte quindi l'intero nel tipo di destinazione seguendo le regole consuete. Ad esempio, per creare un char valore, il compilatore accetta il byte a basso ordine. Per creare un valore wchar_t o char16_t , il compilatore prende la parola meno significativa. Il compilatore avvisa che il risultato sarà troncato se si assegnano bit al di sopra del byte o della parola assegnati.

char c0    = 'abcd';    // C4305, C4309, truncates to 'd'
wchar_t w0 = 'abcd';    // C4305, C4309, truncates to '\x6364'
int i0     = 'abcd';    // 0x61626364

Una sequenza di escape ottale che sembra contenere più di tre cifre viene considerata come una sequenza ottale a 3 cifre, seguita dalle cifre successive come caratteri in un valore letterale multicharacter, che può dare risultati sorprendenti. Ad esempio:

char c1 = '\100';   // '@'
char c2 = '\1000';  // C4305, C4309, truncates to '0'

Le sequenze di escape che sembrano contenere caratteri non ottali vengono valutate come sequenza ottale fino all'ultimo carattere ottale, seguito dai caratteri rimanenti come caratteri successivi in un valore letterale multicaracter. L'avviso C4125 viene generato se il primo carattere non ottale è una cifra decimale. Ad esempio:

char c3 = '\009';   // '9'
char c4 = '\089';   // C4305, C4309, truncates to '9'
char c5 = '\qrs';   // C4129, C4305, C4309, truncates to 's'

Sequenza di escape ottale con un valore superiore rispetto a \377 causa dell'errore C2022: 'value-in-decimal': troppo grande per il carattere.

Una sequenza di escape che sembra avere caratteri esadecimali e non esadecimali viene valutata come valore letterale multicaracter che contiene una sequenza di escape esadecimale fino all'ultimo carattere esadecimale, seguito dai caratteri non esadecimali. Una sequenza di escape esadecimale che non contiene cifre esadecimali causa l'errore del compilatore C2153: "I valori letterali esadecimali devono avere almeno una cifra esadecimale".

char c6 = '\x0050'; // 'P'
char c7 = '\x0pqr'; // C4305, C4309, truncates to 'r'

Se un valore letterale carattere wide preceduto da L contiene una sequenza multicaracter, il valore viene ricavato dal primo carattere e il compilatore genera l'avviso C4066. I caratteri successivi vengono ignorati, a differenza del comportamento del valore letterale multicaracter ordinario equivalente.

wchar_t w1 = L'\100';   // L'@'
wchar_t w2 = L'\1000';  // C4066 L'@', 0 ignored
wchar_t w3 = L'\009';   // C4066 L'\0', 9 ignored
wchar_t w4 = L'\089';   // C4066 L'\0', 89 ignored
wchar_t w5 = L'\qrs';   // C4129, C4066 L'q' escape, rs ignored
wchar_t w6 = L'\x0050'; // L'P'
wchar_t w7 = L'\x0pqr'; // C4066 L'\0', pqr ignored

La sezione specifica di Microsoft termina qui.

nomi di caratteri universali

Nei valori letterali carattere e nei valori letterali stringa (elaborati) nativi, qualsiasi carattere potrà essere rappresentato da un nome di carattere universale. I nomi di caratteri universali sono formati da un prefisso \U seguito da un punto di codice Unicode a otto cifre o da un prefisso \u seguito da un punto di codice Unicode a quattro cifre. Tutte e otto o quattro cifre devono rispettivamente essere presenti per costituire un nome di carattere universale in formato corretto.

char u1 = 'A';          // 'A'
char u2 = '\101';       // octal, 'A'
char u3 = '\x41';       // hexadecimal, 'A'
char u4 = '\u0041';     // \u UCN 'A'
char u5 = '\U00000041'; // \U UCN 'A'

Coppie di surrogati

I nomi di caratteri universali non possono codificare i valori nell'intervallo di punti di codice surrogato D800-DFFF. Per le coppie di surrogati Unicode, specificare il nome di carattere universale usando \UNNNNNNNN, dove NNNNNNNN è il punto di codice a otto cifre per il carattere. Se necessario, il compilatore genera una coppia di surrogati.

In C++03, il linguaggio ha consentito solo un subset di caratteri da rappresentare con i relativi nomi di caratteri universali e ha consentito alcuni nomi di caratteri universali che in realtà non rappresentavano caratteri Unicode validi. Questo errore è stato risolto nello standard C++11. In C++11, sia i valori letterali carattere sia i valori letterali stringa possono usare i nomi di caratteri universali. Per altre informazioni sui nomi di caratteri universali, vedere Character Sets. Per altre informazioni su Unicode, vedere Unicode. Per altre informazioni sulle coppie di surrogati, vedere la pagina relativa alle coppie di surrogati e ai caratteri supplementari.

Valori letterali di stringa

Un valore letterale stringa rappresenta una sequenza di caratteri che insieme formano una stringa con terminazione null. I caratteri devono essere racchiusi tra virgolette doppie. Sono disponibili i seguenti tipi di valori letterali stringa:

Valori letterali stringa stretta

Un valore letterale stringa stretta è una matrice delimitata da virgolette doppie, con terminazione Null di tipo const char[n], dove n è la lunghezza della matrice in byte. Un valore letterale stringa a caratteri "narrow" può contenere qualsiasi carattere grafico eccetto le virgolette doppie ("), la barra rovesciata (\) o un carattere di nuova riga. Un valore letterale stringa a caratteri "narrow" può anche contenere le sequenze di escape sopra elencate e i nomi di caratteri universali che rientrano in un byte.

const char *narrow = "abcd";

// represents the string: yes\no
const char *escaped = "yes\\no";

Stringhe codificate UTF-8

Una stringa con codifica UTF-8 è una matrice con caratteri u8 delimitati da virgolette doppie e con terminazione Null di tipo const char[n], dove n è la lunghezza della matrice codificata in byte. Un valore letterale stringa con prefisso u8 può contenere qualsiasi carattere grafico eccetto le virgolette doppie ("), la barra rovesciata (\) o un carattere di nuova riga. Un valore letterale stringa con prefisso u8 può anche contenere le sequenze di escape sopra elencate e qualsiasi nome di carattere universale.

C++20 introduce il tipo di carattere Unicode con codifica UTF-8 ( char8_t UTF-8). In C++20 i u8 prefissi letterali specificano caratteri o stringhe anziché char8_t .char

// Before C++20
const char* str1 = u8"Hello World";
const char* str2 = u8"\U0001F607 is O:-)";
// C++20 and later
const char8_t* u8str1 = u8"Hello World";
const char8_t* u8str2 = u8"\U0001F607 is O:-)";

Valori letterali stringa wide

Un valore letterale stringa wide è una matrice di costanti wchar_t con terminazione Null preceduta da 'L' e contiene qualsiasi carattere grafico, ad eccezione delle virgolette doppie ("), della barra rovesciata (\) o del carattere di nuova riga. Un valore letterale stringa a caratteri wide può contenere le sequenze di escape sopra elencate e qualsiasi nome di carattere universale.

const wchar_t* wide = L"zyxw";
const wchar_t* newline = L"hello\ngoodbye";

char16_t e char32_t (C++11)

C++11 introduce i tipi di carattere portabili char16_t (Unicode a 16 bit) e char32_t (Unicode a 32 bit):

auto s3 = u"hello"; // const char16_t*
auto s4 = U"hello"; // const char32_t*

Valori letterali stringa non elaborati (C++11)

Un valore letterale stringa non elaborato è una matrice con terminazione Null, di qualsiasi tipo di carattere, che contiene qualsiasi carattere grafico, incluse le virgolette doppie ("), la barra rovesciata (\) o il carattere di nuova riga. I valori letterali stringa non elaborata vengono spesso usati nelle espressioni regolari che usano le classi di caratteri e nelle stringhe HTML e XML. Per gli esempi vedere la pagina relativa alle domande frequenti di Bjarne Stroustrup su C++11.

// represents the string: An unescaped \ character
const char* raw_narrow = R"(An unescaped \ character)";
const wchar_t*  raw_wide  = LR"(An unescaped \ character)";
const char*     raw_utf8a = u8R"(An unescaped \ character)"; // Before C++20
const char8_t*  raw_utf8b = u8R"(An unescaped \ character)"; // C++20
const char16_t* raw_utf16 = uR"(An unescaped \ character)";
const char32_t* raw_utf32 = UR"(An unescaped \ character)";

Un delimitatore è una sequenza definita dall'utente di un massimo di 16 caratteri che precede immediatamente la parentesi di apertura di un valore letterale stringa non elaborata e segue immediatamente la parentesi di chiusura. Ad esempio, in R"abc(Hello"\()abc" la sequenza delimitatore è abc e il contenuto stringa è Hello"\(. È possibile usare un delimitatore per evitare ambiguità tra stringhe non elaborate contenenti sia virgolette doppie che parentesi. Questo valore letterale stringa causa un errore del compilatore:

// meant to represent the string: )"
const char* bad_parens = R"()")";  // error C2059

Tuttavia, un delimitatore è in grado di risolvere tale errore:

const char* good_parens = R"xyz()")xyz";

È possibile costruire un valore letterale stringa non elaborato contenente una nuova riga (non il carattere di escape) nell'origine:

// represents the string: hello
//goodbye
const wchar_t* newline = LR"(hello
goodbye)";

valori letterali std::string (C++14)

std::string i valori letterali sono implementazioni della libreria standard di valori letterali definiti dall'utente (vedere di seguito) rappresentati come "xyz"s (con un s suffisso). Questo tipo di valore letterale stringa produce un oggetto temporaneo di tipo std::string, std::wstring, std::u32stringo std::u16string, a seconda del prefisso specificato. Quando non viene usato alcun prefisso, come sopra, viene prodotto un oggetto std::string . L"xyz"s produce un oggetto std::wstring. u"xyz"s produce un std::u16string e U"xyz"s produce un std::u32string.

//#include <string>
//using namespace std::string_literals;
string str{ "hello"s };
string str2{ u8"Hello World" };     // Before C++20
u8string u8str2{ u8"Hello World" }; // C++20
wstring str3{ L"hello"s };
u16string str4{ u"hello"s };
u32string str5{ U"hello"s };

Il s suffisso può essere usato anche nei valori letterali stringa non elaborati:

u32string str6{ UR"(She said "hello.")"s };

std::string I valori letterali vengono definiti nello spazio dei nomi std::literals::string_literals nel file di intestazione di <stringa> . Poiché std::literals::string_literalse std::literals sono dichiarati come spazi dei nomi inline, std::literals::string_literals verrà considerato automaticamente come appartenente direttamente allo spazio dei nomi std.

Dimensioni dei valori letterali stringa

Per le stringhe ANSI char* e altre codifiche a byte singolo (ma non UTF-8), le dimensioni (in byte) di un valore letterale stringa sono il numero di caratteri più 1 per il carattere Null di terminazione. Per tutti gli altri tipi di stringa, le dimensioni non sono strettamente correlate al numero di caratteri. UTF-8 usa fino a quattro char elementi per codificare alcune unità di codice e char16_t o wchar_t codificate come UTF-16 può usare due elementi (per un totale di quattro byte) per codificare una singola unità di codice. Questo esempio illustra la dimensione di un valore letterale stringa a caratteri wide in byte:

const wchar_t* str = L"Hello!";
const size_t byteSize = (wcslen(str) + 1) * sizeof(wchar_t);

Si noti che strlen() e wcslen() non includono le dimensioni del carattere Null di terminazione, le cui dimensioni sono uguali alle dimensioni dell'elemento del tipo stringa: un byte su una char* stringa o char8_t* , due byte su wchar_t* o char16_t* stringhe e quattro byte per char32_t* le stringhe.

Nelle versioni di Visual Studio precedenti a Visual Studio 2022 versione 17.0, la lunghezza massima di un valore letterale stringa è di 65.535 byte. Questo limite si applica sia ai valori letterali stringa a caratteri narrow che a quelli a caratteri wide. In Visual Studio 2022 versione 17.0 e successive questa restrizione viene rimossa e la lunghezza della stringa è limitata dalle risorse disponibili.

Modifica di valori letterali stringa

Poiché i valori letterali stringa (non inclusi std::string i valori letterali) sono costanti, il tentativo di modificarli, ad esempio, str[2] = 'A'causa un errore del compilatore.

Specifico di Microsoft

In Microsoft C++, è possibile usare un valore letterale stringa per inizializzare un puntatore a non const char o wchar_t. Questa inizializzazione non const è consentita nel codice C99, ma è deprecata in C++98 e rimossa in C++11. Il tentativo di modificare la stringa genera una violazione di accesso, come nel seguente esempio:

wchar_t* str = L"hello";
str[2] = L'a'; // run-time error: access violation

È possibile che il compilatore genera un errore quando un valore letterale stringa viene convertito in un puntatore di caratteri non const quando si imposta l'opzione del /Zc:strictStrings compilatore (Disabilita conversione di tipi letterali stringa). È consigliabile per il codice portabile conforme agli standard. È anche consigliabile usare la auto parola chiave per dichiarare puntatori inizializzati letterali stringa, perché viene risolto nel tipo corretto (const). Ad esempio, l'esempio di codice seguente rileva un tentativo di scrittura in un valore letterale stringa in fase di compilazione:

auto str = L"hello";
str[2] = L'a'; // C3892: you cannot assign to a variable that is const.

In alcuni casi, i valori letterali stringa identici possono essere inseriti in un pool per risparmiare spazio nel file eseguibile. Nel pool di valori letterali stringa il compilatore genera tutti i riferimenti a un valore letterale stringa particolare in modo che punti alla stessa posizione di memoria, anziché avere ogni riferimento che punta a un'istanza separata del valore letterale stringa. Per abilitare il pool di stringhe, usare l'opzione del /GF compilatore.

La sezione specifica di Microsoft termina qui.

Concatenazione dei valori letterali stringa adiacenti

I valori letterali stringa adiacenti a caratteri wide o narrow sono concatenati. La seguente dichiarazione:

char str[] = "12" "34";

è identica a questa dichiarazione:

char atr[] = "1234";

e a questa dichiarazione:

char atr[] =  "12\
34";

L'uso di codici di escape esadecimali incorporati per specificare i valori letterali stringa può provocare risultati imprevisti. L'esempio seguente prova a creare un valore letterale stringa contenente il carattere ASCII 5, seguito dai caratteri f, i, v ed e:

"\x05five"

Il risultato effettivo è un 5F esadecimale, ovvero il codice ASCII per un carattere di sottolineatura, seguito dai caratteri i, v ed e. Per ottenere il risultato corretto, è possibile usare una di queste sequenze di escape:

"\005five"     // Use octal literal.
"\x05" "five"  // Use string splicing.

std::stringI valori letterali (e , e std::u32string) correlati std::u16stringstd::u8stringpossono essere concatenati con l'operatore + definito per basic_string i tipi. Possono essere concatenati anche in modo analogo ai valori letterali stringa adiacenti. In entrambi i casi, la codifica della stringa e il suffisso devono corrispondere:

auto x1 = "hello" " " " world"; // OK
auto x2 = U"hello" " " L"world"; // C2308: disagree on prefix
auto x3 = u8"hello" " "s u8"world"z; // C3688, disagree on suffixes

Valori letterali stringa con nomi di caratteri universali

I valori letterali stringa (elaborata) nativi possono usare i nomi di caratteri universali per rappresentare qualsiasi carattere a condizione che il nome di carattere universale possa essere codificato come uno o più caratteri nel tipo di stringa. Ad esempio, un nome di carattere universale che rappresenta un carattere esteso non può essere codificato in una stringa stretta usando la tabella codici ANSI, ma può essere codificato in stringhe strette in alcune tabelle codici multibyte o in stringhe UTF-8 o in una stringa wide. In C++11 il supporto Unicode viene esteso dai char16_t* tipi stringa e char32_t* C++20 lo estende al char8_t tipo :

// ASCII smiling face
const char*     s1 = ":-)";

// UTF-16 (on Windows) encoded WINKING FACE (U+1F609)
const wchar_t*  s2 = L"😉 = \U0001F609 is ;-)";

// UTF-8  encoded SMILING FACE WITH HALO (U+1F607)
const char*     s3a = u8"😇 = \U0001F607 is O:-)"; // Before C++20
const char8_t*  s3b = u8"😇 = \U0001F607 is O:-)"; // C++20

// UTF-16 encoded SMILING FACE WITH OPEN MOUTH (U+1F603)
const char16_t* s4 = u"😃 = \U0001F603 is :-D";

// UTF-32 encoded SMILING FACE WITH SUNGLASSES (U+1F60E)
const char32_t* s5 = U"😎 = \U0001F60E is B-)";

Vedi anche

Set di caratteri
Valori letterali numerici, booleani e puntatori
Valori letterali definiti dall'utente