Valori letterali stringa C++

Articolo
06/09/2015

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 a caratteri "narrow", rappresentati come "xxx".
Valori letterali stringa a caratteri "wide" rappresentati come L"xxx".
Valori letterali stringa non elaborata, rappresentati come R"ddd(xxx) ddd", in cui ddd è un delimitatore. I valori letterali stringa non elaborata possono essere sia "narrow" (rappresentanti con R) che "wide" (rappresentanti con LR).

Un valore letterale stringa a caratteri "narrow" è una matrice con terminazione null della costante char contenente qualsiasi carattere grafico eccetto le virgolette doppie ("), la barra rovesciata (\) o un carattere di nuova riga. Un valore letterale stringa non può contenere le sequenze di escape elencate in Valori letterali carattere C++.

const char *narrow = "abcd";

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

Un valore letterale stringa a caratteri "wide" è una matrice con terminazione null della costante wchar_t contenente qualsiasi carattere grafico eccetto le virgolette doppie ("), la barra rovesciata (\) o un carattere di nuova riga. Un valore letterale stringa a caratteri "wide" non può contenere le sequenze di escape elencate in Valori letterali carattere C++.

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

Un valore letterale stringa non elaborata è una matrice con terminazione null delle costanti char o wchar_t contenente qualsiasi carattere grafico, inclusi le virgolette doppie ("), la barra rovesciata (\) o un 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)";

// represents the string: An unescaped " character
const wchar_t* raw_wide = LR"(An unescaped " character)";

Un delimitatore è una sequenza definita dall'utente, contenente un massimo di 16 caratteri, che precede immediatamente la parentesi di apertura e segue immediatamente la parentesi di chiusura di un valore letterale stringa non elaborata. È possibile usare un delimitatore per evitare ambiguità tra stringhe contenenti sia virgolette doppie che parentesi. Ciò provoca un errore del compilatore:

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

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

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

È possibile costruire un valore letterale stringa non elaborata in cui è presente una nuova riga (non un carattere di escape) nell'origine:

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

Dimensioni dei valori letterali stringa

La dimensione in byte di un valore letterale stringa a caratteri "narrow" è costituita dal numero di caratteri più 1 (per il carattere di terminazione null) e la dimensione in byte di un valore letterale stringa a caratteri "wide" è costituita da 2 volte il numero di caratteri più 2 (per il carattere di terminazione null). Di seguito viene illustrata la dimensione di un valore letterale stringa a caratteri "wide":

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

Notare che strlen() e wcslen() non includono la dimensione del carattere di terminazione null.

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".

Modifica dei valori letterali stringa

Poiché i valori letterali stringa sono delle costanti, il tentativo di modificarli, ad esempio str[2] = 'A', causa un errore del compilatore.

Sezione specifica Microsoft

In Visual C++ è possibile usare un valore letterale stringa per inizializzare un puntatore a char o wchar_t non const. Questa operazione è consentita nel codice C, 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 fare in modo che il compilatore generi un errore quando un valore letterale stringa viene convertito in un carattere non_const quando si imposta l'opzione del compilatore /Zc:strictStrings (Disabilitare la conversione del tipo di valore letterale stringa). È consigliabile usare la parola chiave auto per dichiarare i puntatori inizializzati dal valore letterale stringa poiché viene risolta nel tipo (const) corretto. Ad esempio, nell'esempio seguente viene rilevato un tentativo di scrittura in un valore letterale stringa in fase di compilazione:

auto str = L"hello";
str[2] = L'a'; // Compiler error: 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 la condivisione delle stringhe, usare l'opzione del compilatore /GF.

Fine sezione specifica Microsoft

Concatenazione dei valori letterali stringa adiacenti

I valori letterali stringa adiacenti 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'utilizzo di codici di escape esadecimali incorporati per specificare le costanti di stringa può provocare risultati imprevisti. Nell'esempio seguente si tenta di 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 uno dei seguenti codici:

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