Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
C++ suporta vários tipos de cadeia de caracteres e caracteres, e fornece maneiras de expressar valores literais de cada um desses tipos. No código-fonte, você expressa o conteúdo dos literais de caracteres e cadeias de caracteres usando um conjunto de caracteres. Nomes de caracteres universais e caracteres de escape permitem que você expresse qualquer cadeia de caracteres usando apenas o conjunto básico de caracteres de origem. Um literal de cadeia de caracteres bruto permite evitar o uso de caracteres de escape e pode ser usado para expressar todos os tipos de literais de cadeia de caracteres. Você também pode realizar a criação de std::string literais sem precisar realizar etapas adicionais de construção ou conversão.
#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
}
Os literais de cadeia de caracteres não podem ter prefixo, ou u8, Lu, e U prefixos para denotar caracteres estreitos (byte único ou multibyte), UTF-8, caracteres largos (UCS-2 ou UTF-16), codificações UTF-16 e UTF-32, respectivamente. Um literal de cadeia de caracteres bruto pode ter R, u8R, LR, uRe UR prefixos para os equivalentes de versão bruta dessas codificações. Para criar valores temporários ou estáticos std::string , você pode usar literais de cadeia de caracteres ou literais de cadeia de caracteres brutos com um s sufixo. Para obter mais informações, consulte a seção Literais de cadeia de caracteres abaixo. Para obter mais informações sobre o conjunto básico de caracteres de origem, nomes de caracteres universais e o uso de caracteres de páginas de código estendidas em seu código-fonte, consulte Conjuntos de caracteres.
Literais de caracteres
Um literal de caractere é composto por um caractere constante. É representado pelo caractere rodeado por aspas simples. Existem cinco tipos de literais de caracteres:
Literais comuns de tipo
char, por exemplo'a'Literais de caracteres UTF-8 do tipo
char(char8_tem C++20), por exemplou8'a'Literais de caracteres largos do tipo
wchar_t, por exemploL'a'Literais de caracteres UTF-16 do tipo
char16_t, por exemplou'a'Literais de caracteres UTF-32 do tipo
char32_t, por exemploU'a'
O caractere usado para um literal de caractere pode ser qualquer caractere, exceto para a barra invertida de caracteres reservados (\), aspas simples (') ou nova linha. Os caracteres reservados podem ser especificados usando uma sequência de escape. Os caracteres podem ser especificados usando nomes de caracteres universais, desde que o tipo seja grande o suficiente para conter o caractere.
Codificação
Os literais de caracteres são codificados de forma diferente com base em seu prefixo.
Um literal de caractere sem prefixo é um literal de caractere comum. O valor de um literal de caractere comum contendo um único caractere, sequência de escape ou nome de caractere universal que pode ser representado no conjunto de caracteres de execução tem um valor igual ao valor numérico de sua codificação no conjunto de caracteres de execução. Um literal de caractere comum que contém mais de um caractere, sequência de escape ou nome de caractere universal é um literal de vários caracteres. Um literal de vários caracteres ou um literal de caracteres comuns que não pode ser representado no conjunto de caracteres de execução tem tipo
int, e seu valor é definido pela implementação. Para MSVC, consulte a seção específica da Microsoft abaixo.Um literal de caractere que começa com o prefixo
Lé um literal de caractere largo. O valor de um literal de caracteres largos contendo um único caractere, sequência de escape ou nome de caractere universal tem um valor igual ao valor numérico de sua codificação no conjunto de caracteres largos de execução, a menos que o literal de caracteres não tenha representação no conjunto de caracteres largos de execução, caso em que o valor é definido pela implementação. O valor de um literal de caracteres largos contendo vários caracteres, sequências de escape ou nomes de caracteres universais é definido pela implementação. Para MSVC, consulte a seção específica da Microsoft abaixo.Um literal de caractere que começa com o prefixo
u8é um literal de caractere UTF-8. O valor de um literal de carácter UTF-8 que contém um único carácter, uma sequência de escape ou um nome de carácter universal é igual ao seu valor de ponto de código ISO 10646, se puder ser representado por uma única unidade de código UTF-8 (correspondente aos Controles C0 e ao bloco Unicode Latino Básico). Se o valor não pode ser representado por uma única unidade de código UTF-8, o programa está mal formado. Um literal de caractere UTF-8 contendo mais de um caractere, sequência de escape ou nome de caractere universal está mal formado.Um literal de caractere que começa com o prefixo
ué um literal de caractere UTF-16. O valor de um literal de caracteres UTF-16 contendo um único caractere, sequência de escape ou nome de caractere universal tem um valor igual ao seu valor de ponto de código ISO 10646 se puder ser representado por uma única unidade de código UTF-16 (correspondente ao plano multilíngüe básico). Se o valor não pode ser representado por uma única unidade de código UTF-16, o programa está mal formado. Um literal de caractere UTF-16 contendo mais de um caractere, sequência de escape ou nome de caractere universal está mal formado.Um literal de caractere que começa com o prefixo
Ué um literal de caractere UTF-32. O valor de um literal de caractere UTF-32 contendo um único caractere, sequência de escape ou nome de caractere universal é igual ao seu ponto de código ISO 10646. Um literal de caractere UTF-32 contendo mais de um caractere, sequência de escape ou nome de caractere universal está mal formado.
Sequências de fuga
Existem três tipos de sequências de escape: simples, octal e hexadecimal. As sequências de escape podem ser qualquer um dos seguintes valores:
| Valor | Sequência de fuga |
|---|---|
| nova linha | \n |
| barra invertida | \\ |
| tabulação horizontal | \t |
| ponto de interrogação | ? ou \? |
| separador vertical | \v |
| citação única | \' |
| tecla de retrocesso | \b |
| citação dupla | \" |
| Retorno de carro | \r |
| O caractere nulo | \0 |
| feed de formulários | \f |
| octal | \ooo |
| alerta (campainha) | \um |
| hexadecimal | \xhhh |
Uma sequência de escape octal é uma barra invertida seguida por uma sequência de um a três dígitos octais. Uma sequência de escape octal termina no primeiro caractere que não é um dígito octal, se encontrado antes do terceiro dígito. O maior valor octal possível é \377.
Uma sequência de escape hexadecimal é uma barra invertida seguida pelo caractere x, seguida por uma sequência de um ou mais dígitos hexadecimais. Os zeros à esquerda são ignorados. Em um literal de caracteres comum ou prefixado com u8, o valor hexadecimal mais elevado é 0xFF. Em um literal de caracteres largos prefixado em L ou em U, o valor hexadecimal mais alto é 0xFFFF. Em um literal de caracteres largos prefixados em U, o valor hexadecimal mais alto é 0xFFFFFFFF.
Este código de exemplo apresenta alguns exemplos de caracteres escapados usando literais de caracteres normais. A mesma sintaxe de sequência de escape é válida para os outros tipos literais de caracteres.
#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
*/
O caractere de barra invertida (\) é um caractere de continuação de linha quando é colocado no final de uma linha. Se quiser que um caractere de barra invertida apareça como um literal de caractere, digite duas barras invertidas seguidas (\\). Para obter mais informações sobre o caractere de continuação de linha, consulte Fases de tradução.
Específico da Microsoft
Para criar um valor a partir de um literal estreito de múltiplos caracteres, o compilador converte os caracteres entre aspas simples em valores de 8 bits dentro de um número inteiro de 32 bits. Vários caracteres no literal preenchem os bytes correspondentes, conforme necessário, da ordem mais alta para a ordem mais baixa. Em seguida, o compilador converte o inteiro para o tipo de destino seguindo as regras usuais. Por exemplo, para criar um char valor, o compilador usa o byte de ordem baixa. Para criar um wchar_t ou char16_t valor, o compilador usa a palavra de ordem baixa. O compilador avisa que o resultado é truncado se algum bit for definido além do byte ou palavra atribuída.
char c0 = 'abcd'; // C4305, C4309, truncates to 'd'
wchar_t w0 = 'abcd'; // C4305, C4309, truncates to '\x6364'
int i0 = 'abcd'; // 0x61626364
Uma sequência de escape octal que parece conter mais de três dígitos é tratada como uma sequência octal de 3 dígitos, com os dígitos subsequentes tratados como caracteres em um literal multicarácter, o que pode produzir resultados inesperados. Por exemplo:
char c1 = '\100'; // '@'
char c2 = '\1000'; // C4305, C4309, truncates to '0'
As sequências de fuga que parecem conter caracteres não octais são avaliadas como uma sequência octal até ao último caractere octal, seguido pelos restantes como caracteres subsequentes em um literal de vários caracteres. O aviso C4125 é gerado se o primeiro caractere não octal for um dígito decimal. Por exemplo:
char c3 = '\009'; // '9'
char c4 = '\089'; // C4305, C4309, truncates to '9'
char c5 = '\qrs'; // C4129, C4305, C4309, truncates to 's'
Uma sequência de escape octal com um valor maior do que \377 causa o erro C2022: 'valor-em-decimal': demasiado grande para um caractere.
Uma sequência de escape que parece ter caracteres hexadecimais e não hexadecimais é avaliada como um literal de múltiplos caracteres que contém uma sequência de escape hexadecimal até ao último caractere hexadecimal, seguido pelos caracteres não hexadecimais. Uma sequência de escape hexadecimal que não contém dígitos hexadecimais causa o erro do compilador C2153: "literais hexadecimais devem ter pelo menos um dígito hexadecimal".
char c6 = '\x0050'; // 'P'
char c7 = '\x0pqr'; // C4305, C4309, truncates to 'r'
Se um literal de caractere largo prefixado com L contém uma sequência de vários caracteres, o valor é retirado do primeiro caractere e o compilador gera aviso C4066. Os caracteres subsequentes são ignorados, ao contrário do comportamento de um literal ordinário equivalente de múltiplos caracteres.
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
A seção específica da Microsoft termina aqui.
Nomes de caracteres universais
Em literais de caracteres e literais de cadeia de caracteres nativos (não brutos), qualquer caractere pode ser representado por um nome de caractere universal. Os nomes de caracteres universais são formados por um prefixo \U seguido por um ponto de código Unicode de oito dígitos, ou por um prefixo \u seguido por um ponto de código Unicode de quatro dígitos. Todos os oito ou quatro dígitos, respectivamente, devem estar presentes para fazer um nome de caractere universal bem formado.
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'
Pares substitutos
Nomes de caracteres universais não podem codificar valores no intervalo de pontos de código substituto D800-DFFF. Para pares substitutos Unicode, especifique o nome universal do caractere usando \UNNNNNNNN, onde NNNNNNNN é o ponto de código de oito dígitos para o caractere. O compilador gera um par substituto, se necessário.
Em C++03, a linguagem permitia apenas que um subconjunto de caracteres fosse representado por seus nomes de caracteres universais e permitia alguns nomes de caracteres universais que não representavam nenhum caractere Unicode válido. Este erro foi corrigido no padrão C++11. Em C++11, literais de caracteres e de cadeias de caracteres, bem como identificadores, podem usar nomes de caracteres universais. Para obter mais informações sobre nomes de caracteres universais, consulte Conjuntos de caracteres. Para obter mais informações sobre Unicode, consulte Unicode. Para obter mais informações sobre pares substitutos, consulte Pares substitutos e caracteres suplementares.
Cadeias literais
Um literal de cadeia de caracteres representa uma sequência de caracteres que, juntos, formam uma cadeia de caracteres terminada em nulo. Os caracteres devem estar entre aspas duplas. Existem os seguintes tipos de literais de cadeia de caracteres:
Literais de cadeia de caracteres estreitos
Um literal de cadeia de caracteres estreita é uma matriz do tipo const char[n]não-prefixada, delimitada por aspas duplas, terminada em nulo, onde n é o comprimento da matriz em bytes. Uma cadeia de caracteres restrita pode conter qualquer símbolo gráfico, exceto aspas duplas ("), barra invertida (\) ou caractere de nova linha. Um literal de cadeia de caracteres estreita também pode conter as sequências de escape listadas acima e nomes de caracteres universais que cabem em um byte.
const char *narrow = "abcd";
// represents the string: yes\no
const char *escaped = "yes\\no";
Strings codificadas em UTF-8
Uma cadeia de caracteres codificada UTF-8 é uma matriz do tipo const char[n]u8-prefixed, delimitada por aspas duplas, terminada em nulo, onde n é o comprimento da matriz codificada em bytes. Um literal de cadeia de caracteres prefixado com u8 pode conter qualquer caractere gráfico, com exceção de aspas duplas ("), barra invertida (\) ou caractere de nova linha. Um literal de cadeia de caracteres com prefixo u8 também pode conter as sequências de escape listadas acima e qualquer nome de caractere universal.
O C++20 introduz o tipo de caractere portátil char8_t (Unicode de 8 bits codificado em UTF-8). Em C++20, u8 prefixos literais especificam caracteres ou cadeias de caracteres char8_t, em vez de 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:-)";
Literais de cadeia larga
Um literal de cadeia de caracteres larga é uma matriz de constante wchar_t terminada em nulo que é prefixada por 'L' e contém qualquer caractere gráfico, exceto aspas duplas ("), barra invertida (\) ou caractere de nova linha. Um literal de cadeia de caracteres larga pode conter as sequências de escape listadas acima e qualquer nome de caractere universal.
const wchar_t* wide = L"zyxw";
const wchar_t* newline = L"hello\ngoodbye";
char16_t e char32_t (C++11)
O C++11 apresenta os tipos de caracteres portáteis char16_t (Unicode de 16 bits) e char32_t Unicode (32 bits):
auto s3 = u"hello"; // const char16_t*
auto s4 = U"hello"; // const char32_t*
Literais de cadeia de caracteres brutas (C++11)
Um literal de cadeia de caracteres bruta é uma matriz terminada em nulo — de qualquer tipo de caractere — que contém qualquer caractere gráfico, incluindo aspas duplas ("), barra invertida (\) ou caractere de nova linha. Literais de cadeia brutos são frequentemente usados em expressões regulares que utilizam classes de caracteres e em cadeias HTML e XML. Para obter exemplos, consulte o seguinte artigo: Perguntas frequentes de Bjarne Stroustrup em 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)";
Um delimitador é uma sequência definida pelo utilizador de até 16 caracteres que precede imediatamente o parêntese de abertura de um literal de cadeia de texto bruto e imediatamente segue o seu parêntese de fecho. Por exemplo, na R"abc(Hello"\()abc" sequência do delimitador é abc e o conteúdo da cadeia de caracteres é Hello"\(. Você pode usar um delimitador para desambiguar cadeias de caracteres brutas que contenham aspas duplas e parênteses. Este literal de cadeia de caracteres causa um erro de compilação:
// meant to represent the string: )"
const char* bad_parens = R"()")"; // error C2059
Mas um delimitador resolve:
const char* good_parens = R"xyz()")xyz";
Você pode construir uma cadeia de caracteres bruta literal que contém uma nova linha (não o caractere escapado) na origem:
// represents the string: hello
//goodbye
const wchar_t* newline = LR"(hello
goodbye)";
std::literais de cadeia de caracteres (C++14)
std::string literais são implementações de biblioteca padrão de literais definidos pelo usuário (veja abaixo) que são representados como "xyz"s (com um s sufixo). Esse tipo de literal de cadeia de caracteres produz um objeto temporário do tipo std::string, , std::wstringstd::u32string, ou std::u16string, dependendo do prefixo especificado. Quando nenhum prefixo é usado, como acima, um std::string é produzido.
L"xyz"s produz um std::wstring.
u"xyz"s produz um std::u16string e U"xyz"s produz um 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 };
O sufixo s também pode ser usado em literais de cadeia de caracteres brutos:
u32string str6{ UR"(She said "hello.")"s };
std::string literais são definidos no namespace std::literals::string_literals no arquivo de cabeçalho de <cadeia de caracteres> . Porque std::literals::string_literals, e std::literals ambos são declarados como namespaces embutidos, std::literals::string_literals é automaticamente tratado como se pertencesse diretamente ao namespace std.
Tamanho dos literais de cadeia de caracteres
Para cadeias de caracteres ANSI char* e outras codificações de byte único (mas não UTF-8), o tamanho (em bytes) de um literal de cadeia de caracteres é o número de caracteres mais 1 para o caractere nulo de terminação. Para todos os outros tipos de cadeia de caracteres, o tamanho não está estritamente relacionado ao número de caracteres. UTF-8 usa até quatro char elementos para codificar algumas unidades de código, e char16_t ou wchar_t codificado como UTF-16 pode usar dois elementos (para um total de quatro bytes) para codificar uma única unidade de código. Este exemplo mostra o tamanho de uma cadeia de caracteres larga literal em bytes:
const wchar_t* str = L"Hello!";
const size_t byteSize = (wcslen(str) + 1) * sizeof(wchar_t);
Note que strlen() e wcslen() não incluem o tamanho do caractere nulo de terminação, cujo tamanho é igual ao tamanho do elemento do tipo de cadeia de caracteres: um byte em cadeias de caracteres char* ou char8_t*, dois bytes em cadeias de caracteres wchar_t* ou char16_t*, e quatro bytes em cadeias de caracteres char32_t*.
Comprimento máximo de um literal de cadeia de caracteres após concatenação:
- Visual Studio anterior à versão 17.0 de 2022: o comprimento máximo de uma cadeia de caracteres literal após concatenação é de 65,535 bytes. Isso se aplica a literais de cadeia de caracteres estreitos e largos.
- A partir da versão 17.0 do Visual Studio 2022, o comprimento máximo de um literal de cadeia de caracteres após a concatenação é apenas limitado pela memória disponível. No entanto, o limite de tamanho antes da concatenação ainda é de 16.384 bytes
Modificando literais de cadeia de caracteres
Como literais de strings (não incluindo std::string literais) são constantes, tentar modificá-los — por exemplo, str[2] = 'A'— causa um erro do compilador.
Específico da Microsoft
No C++ da Microsoft, você pode usar um literal de cadeia para inicializar um ponteiro para não-constante char ou wchar_t. Essa inicialização não-const é permitida no código C99, mas é preterida em C++98 e removida em C++11. Uma tentativa de modificar a cadeia de caracteres causa uma violação de acesso, como neste exemplo:
wchar_t* str = L"hello";
str[2] = L'a'; // run-time error: access violation
Você pode fazer com que o compilador emita um erro quando um string literal é convertido em um ponteiro de carácter não-constante ao definir a opção de compilador (Desativar conversão de tipo de string literal). Recomendamos isto para código portátil em conformidade com as normas. Também é uma boa prática usar a auto palavra-chave para declarar ponteiros inicializados com literais de cadeia de caracteres, porque isto se resolve no tipo correto (const). Por exemplo, este exemplo de código deteta uma tentativa de escrever em um literal de string durante a compilação.
auto str = L"hello";
str[2] = L'a'; // C3892: you cannot assign to a variable that is const.
Em alguns casos, strings literais idênticas podem ser agrupadas para economizar espaço no ficheiro executável. Na agregação de literais de cadeias, o compilador faz com que todas as referências a um literal de cadeia específico apontem para o mesmo local na memória, em vez de cada referência apontar para uma instância separada do literal de cadeia. Para habilitar o pool de cadeias de caracteres, use a opção de compilador /GF.
A seção específica da Microsoft termina aqui.
Concatenando literais de cadeia de caracteres adjacentes
Literais de cadeia de caracteres largos ou estreitos adjacentes são concatenados. Esta declaração:
char str[] = "12" "34";
é idêntica à presente declaração:
char atr[] = "1234";
e à presente declaração:
char atr[] = "12\
34";
Usar códigos de escape hexadecimais incorporados para especificar literais de cadeia de caracteres pode causar resultados inesperados. O exemplo a seguir procura criar um literal de cadeia de caracteres que contém o caractere ASCII 5, seguido pelos caracteres f, i, v e e:
"\x05five"
O resultado real é um 5F hexadecimal, que é o código ASCII para um sublinhado, seguido pelos caracteres i, v e e. Para obter o resultado correto, você pode usar uma destas sequências de escape:
"\005five" // Use octal literal.
"\x05" "five" // Use string splicing.
std::string literais (e os relacionados std::u8string, std::u16string, e std::u32string) podem ser concatenados com o operador + definido para tipos basic_string. Eles também podem ser concatenados da mesma forma que literais de cadeia de caracteres adjacentes. Em ambos os casos, a codificação de cadeia de caracteres e o sufixo devem corresponder:
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
Literais de string com nomes de caracteres universais
Literais de cadeia de caracteres nativos (não brutos) podem usar nomes de caracteres universais para representar qualquer caractere, desde que o nome de caractere universal possa ser codificado como um ou mais caracteres no tipo de cadeia de caracteres. Por exemplo, um nome de caractere universal que representa um caractere estendido não pode ser codificado em uma cadeia de caracteres estreita usando a página de código ANSI, mas pode ser codificado em cadeias de caracteres estreitas em algumas páginas de código de vários bytes, ou em cadeias de caracteres UTF-8, ou em uma cadeia de caracteres larga. Em C++11, o suporte a Unicode é ampliado pelos tipos de cadeia de caracteres char16_t* e char32_t*, e o C++20 estende isso ao tipo char8_t.
// 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-)";
Ver também
Conjuntos de caracteres
Literais numéricos, booleanos e de ponteiro
Literais definidos pelo usuário