String dan literal karakter (C++)

C++ mendukung berbagai jenis string dan karakter, dan menyediakan cara untuk mengekspresikan nilai harfiah dari masing-masing jenis ini. Dalam kode sumber, Anda mengekspresikan konten karakter dan string literal menggunakan set karakter. Nama karakter universal dan karakter escape memungkinkan Anda mengekspresikan string apa pun hanya menggunakan kumpulan karakter sumber dasar. String mentah harfiah memungkinkan Anda menghindari penggunaan karakter escape, dan dapat digunakan untuk mengekspresikan semua jenis string literal. Anda juga dapat membuat std::string literal tanpa harus melakukan langkah-langkah konstruksi atau konversi tambahan.

#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
}

Literal string tidak dapat memiliki awalan, atau u8, L, u, dan U awalan untuk menunjukkan karakter sempit (byte tunggal atau multi-byte), UTF-8, karakter lebar (UCS-2 atau UTF-16), pengodean UTF-16 dan UTF-32, masing-masing. Literal string mentah dapat memiliki Rawalan , u8R, LRuR, , dan UR untuk versi mentah yang setara dengan pengodean ini. Untuk membuat nilai sementara atau statis std::string , Anda dapat menggunakan literal string atau literal string mentah dengan akhiran s . Untuk informasi selengkapnya, lihat bagian Literal string di bawah ini. Untuk informasi selengkapnya tentang kumpulan karakter sumber dasar, nama karakter universal, dan menggunakan karakter dari halaman kode yang diperluas dalam kode sumber Anda, lihat Kumpulan karakter.

Harfiah karakter

Karakter harfiah terdiri dari karakter konstanta. Ini diwakili oleh karakter yang dikelilingi oleh tanda kutip tunggal. Ada lima jenis literal karakter:

• Literal karakter biasa dari jenis char, misalnya 'a'

• Literal karakter UTF-8 dari jenis char (char8_t dalam C++20), misalnya u8'a'

• Literal berkarakter lebar dari jenis wchar_t, misalnya L'a'

• Literal karakter UTF-16 dari jenis char16_t, misalnya u'a'

• Literal karakter UTF-32 dari jenis char32_t, misalnya U'a'

Karakter yang digunakan untuk karakter harfiah dapat berupa karakter apa pun, kecuali untuk garis miring terbalik karakter yang dipesan (\), tanda kutip tunggal ('), atau baris baru. Karakter yang dipesan dapat ditentukan dengan menggunakan urutan escape. Karakter dapat ditentukan dengan menggunakan nama karakter universal, selama jenisnya cukup besar untuk menahan karakter.

Pengodean

Literal karakter dikodekan secara berbeda berdasarkan awalannya.

• Karakter harfiah tanpa awalan adalah karakter biasa harfiah. Nilai karakter biasa harfiah yang berisi karakter tunggal, urutan escape, atau nama karakter universal yang dapat diwakili dalam set karakter eksekusi memiliki nilai yang sama dengan nilai numerik pengodeannya dalam set karakter eksekusi. Karakter biasa harfiah yang berisi lebih dari satu karakter, urutan escape, atau nama karakter universal adalah literal multicharacter. Literal multicharacter atau literal karakter biasa yang tidak dapat diwakili dalam set karakter eksekusi memiliki jenis int, dan nilainya ditentukan implementasi. Untuk MSVC, lihat bagian khusus Microsoft di bawah ini.

• Karakter harfiah yang dimulai dengan awalan L adalah literal karakter lebar. Nilai literal karakter lebar yang berisi karakter tunggal, urutan escape, atau nama karakter universal memiliki nilai yang sama dengan nilai numerik pengodeannya dalam set karakter lebar eksekusi kecuali karakter harfiah tidak memiliki representasi dalam set karakter lebar eksekusi, dalam hal ini nilai ditentukan implementasi. Nilai literal karakter lebar yang berisi beberapa karakter, urutan escape, atau nama karakter universal ditentukan implementasi. Untuk MSVC, lihat bagian khusus Microsoft di bawah ini.

• Karakter harfiah yang dimulai dengan awalan u8 adalah literal karakter UTF-8. Nilai literal karakter UTF-8 yang berisi satu karakter, urutan escape, atau nama karakter universal memiliki nilai yang sama dengan nilai titik kode ISO 10646 jika dapat diwakili oleh satu unit kode UTF-8 (sesuai dengan kontrol C0 dan blok Unicode Latin Dasar). Jika nilai tidak dapat diwakili oleh satu unit kode UTF-8, program akan terbentuk dengan tidak benar. Literal karakter UTF-8 yang berisi lebih dari satu karakter, urutan escape, atau nama karakter universal berbentuk buruk.

• Karakter harfiah yang dimulai dengan awalan u adalah literal karakter UTF-16. Nilai literal karakter UTF-16 yang berisi satu karakter, urutan escape, atau nama karakter universal memiliki nilai yang sama dengan nilai titik kode ISO 10646 jika dapat diwakili oleh satu unit kode UTF-16 (sesuai dengan bidang multibahasa dasar). Jika nilai tidak dapat diwakili oleh satu unit kode UTF-16, program akan terbentuk dengan tidak benar. Karakter UTF-16 harfiah yang berisi lebih dari satu karakter, urutan escape, atau nama karakter universal berbentuk buruk.

• Literal karakter yang dimulai dengan awalan U adalah literal karakter UTF-32. Nilai literal karakter UTF-32 yang berisi satu karakter, urutan escape, atau nama karakter universal memiliki nilai yang sama dengan nilai titik kode ISO 10646. Literal karakter UTF-32 yang berisi lebih dari satu karakter, urutan escape, atau nama karakter universal berbentuk buruk.

Urutan escape

Ada tiga jenis urutan escape: sederhana, oktal, dan heksadesimal. Urutan escape mungkin salah satu nilai berikut:

Nilai	Urutan escape
baris baru	\n
Backslash	\\
tab horizontal	\t
tanda tanya	? Atau\?
tab vertikal	\v
kutipan tunggal	\'
Backspace	\b
kutipan ganda	\"
Kembali ke awal	\r
karakter null	\0
umpan formulir	\f
Oktal	\Ooo
pemberitahuan (bel)	\a
Heksadesimal	\xhhh

Urutan pelarian oktal adalah garis miring terbalik diikuti oleh urutan satu hingga tiga digit oktal. Urutan escape oktal berakhir pada karakter pertama yang bukan digit oktal, jika ditemui lebih cepat dari digit ketiga. Nilai oktal setinggi mungkin adalah \377.

Urutan escape heksadesimal adalah garis miring terbalik diikuti oleh karakter x, diikuti dengan urutan satu atau beberapa digit heksadesimal. Nol di depan diabaikan. Dalam karakter literal awalan biasa atau u8, nilai heksadesimal tertinggi adalah 0xFF. Dalam literal karakter lebar awalan L atau u-awalan, nilai heksadesimal tertinggi adalah 0xFFFF. Dalam literal karakter lebar berawalan U, nilai heksadesimal tertinggi adalah 0xFFFFFFFF.

Kode sampel ini menunjukkan beberapa contoh karakter yang lolos menggunakan literal karakter biasa. Sintaks urutan escape yang sama valid untuk jenis literal karakter lainnya.

#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
*/

Karakter garis miring terbelakang (\) adalah karakter kelanjutan garis saat ditempatkan di akhir garis. Jika Anda ingin karakter garis miring terbalik muncul sebagai karakter harfiah, Anda harus mengetik dua garis miring terbalik berturut-turut (\\). Untuk informasi selengkapnya tentang karakter kelanjutan baris, lihat Fase Terjemahan.

Khusus Microsoft

Untuk membuat nilai dari literal multicharacter sempit, kompilator mengonversi urutan karakter atau karakter antara tanda kutip tunggal menjadi nilai 8-bit dalam bilangan bulat 32-bit. Beberapa karakter dalam literal mengisi byte yang sesuai sesuai kebutuhan dari urutan tinggi hingga urutan rendah. Pengkompilasi kemudian mengonversi bilangan bulat ke jenis tujuan mengikuti aturan biasa. Misalnya, untuk membuat char nilai, pengkompilasi mengambil byte urutan rendah. Untuk membuat wchar_t nilai atau char16_t , pengkompilasi mengambil kata berurutan rendah. Pengkompilasi memperingatkan bahwa hasilnya dipotong jika ada bit yang diatur di atas byte atau kata yang ditetapkan.

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

Urutan escape oktal yang tampaknya berisi lebih dari tiga digit diperlakukan sebagai urutan oktal 3 digit, diikuti oleh digit berikutnya sebagai karakter dalam literal multicharacter, yang dapat memberikan hasil yang mengejutkan. Contohnya:

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

Urutan escape yang tampaknya berisi karakter non-oktal dievaluasi sebagai urutan oktal hingga karakter oktal terakhir, diikuti oleh karakter yang tersisa sebagai karakter berikutnya dalam literal multicharacter. Peringatan C4125 dihasilkan jika karakter non-oktal pertama adalah digit desimal. Contohnya:

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

Urutan escape oktal yang memiliki nilai lebih tinggi daripada \377 menyebabkan kesalahan C2022: 'value-in-decimal': terlalu besar untuk karakter.

Urutan escape yang tampaknya memiliki karakter heksadesimal dan non-heksadesimal dievaluasi sebagai literal multikarakter yang berisi urutan escape heksadesimal hingga karakter heksadesimal terakhir, diikuti oleh karakter non-heksadesimal. Urutan escape heksadesimal yang tidak berisi digit heksadesimal menyebabkan kesalahan kompilator C2153: "literal heksadesimal harus memiliki setidaknya satu digit heksadesimal".

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

Jika karakter lebar harfiks yang diawali dengan L berisi urutan multicharacter, nilai diambil dari karakter pertama, dan kompilator memunculkan peringatan C4066. Karakter berikutnya diabaikan, tidak seperti perilaku literal multicharacter biasa yang setara.

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

Bagian khusus Microsoft berakhir di sini.

Nama karakter universal

Dalam literal karakter dan literal string asli (non-mentah), karakter apa pun dapat diwakili oleh nama karakter universal. Nama karakter universal dibentuk oleh awalan \U diikuti oleh titik kode Unicode delapan digit, atau dengan awalan \u diikuti dengan titik kode Unicode empat digit. Ketiganya masing-masing delapan atau empat digit harus hadir untuk membuat nama karakter universal yang terbentuk dengan baik.

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'

Pasangan Pengganti

Nama karakter universal tidak dapat mengodekan nilai dalam rentang titik kode pengganti D800-DFFF. Untuk pasangan pengganti Unicode, tentukan nama karakter universal dengan menggunakan \UNNNNNNNN, di mana NNNNNNNN adalah titik kode delapan digit untuk karakter. Pengkompilasi menghasilkan pasangan pengganti jika perlu.

Dalam C++03, bahasa hanya mengizinkan subkumpulan karakter diwakili oleh nama karakter universalnya, dan memungkinkan beberapa nama karakter universal yang sebenarnya tidak mewakili karakter Unicode yang valid. Kesalahan ini diperbaiki dalam standar C++11. Di C++11, karakter dan string literal dan pengidentifikasi dapat menggunakan nama karakter universal. Untuk informasi selengkapnya tentang nama karakter universal, lihat Kumpulan Karakter. Untuk informasi selengkapnya tentang Unicode, lihat Unicode. Untuk informasi selengkapnya tentang pasangan pengganti, lihat Pasangan Pengganti dan Karakter Tambahan.

Literal string

String literal mewakili urutan karakter yang bersama-sama membentuk string yang dihentikan null. Karakter harus diapit di antara tanda kutip ganda. Ada jenis literal string berikut:

Literal string sempit

String sempit literal adalah array jenis const char[n]yang tidak diawali, dibatasi tanda kutip ganda, dan dihentikan null , di mana n adalah panjang array dalam byte. String sempit harfiah mungkin berisi karakter grafis apa pun kecuali tanda kutip ganda ("), garis miring terbalik (\), atau karakter baris baru. String sempit literal juga dapat berisi urutan escape yang tercantum di atas, dan nama karakter universal yang pas dalam byte.

const char *narrow = "abcd";

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

String yang dikodekan UTF-8

String yang dikodekan UTF-8 adalah array jenis const char[n]yang dibatasi dengan awalan u8, kuotasi ganda, dan dihentikan null , di mana n adalah panjang array yang dikodekan dalam byte. String literal dengan awalan u8 mungkin berisi karakter grafik apa pun kecuali tanda kutip ganda ("), garis miring terbalik (\), atau karakter baris baru. String literal berawalan u8 juga dapat berisi urutan escape yang tercantum di atas, dan nama karakter universal apa pun.

C++20 memperkenalkan jenis karakter portabel char8_t (Unicode 8-bit yang dikodekan UTF-8). Dalam C++20, u8 awalan literal menentukan karakter atau string alih-alih char8_tchar.

// 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:-)";

Literal string lebar

Literal string lebar adalah array konstanta wchar_t yang dihentikan null yang diawali oleh 'L' dan berisi karakter grafik apa pun kecuali tanda kutip ganda ("), garis miring terbalik (\), atau karakter garis baru. String lebar harfiah mungkin berisi urutan escape yang tercantum di atas dan nama karakter universal apa pun.

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

char16_t dan char32_t (C++11)

C++11 memperkenalkan jenis karakter portabel char16_t (Unicode 16-bit) dan char32_t (Unicode 32-bit):

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

Literal string mentah (C++11)

String mentah literal adalah array null-terminated—dari jenis karakter apa pun—yang berisi karakter grafis apa pun, termasuk tanda kutip ganda ("), garis miring terbalik (\), atau karakter baris baru. Literal string mentah sering digunakan dalam ekspresi reguler yang menggunakan kelas karakter, dan dalam string HTML dan string XML. Misalnya, lihat artikel berikut: FAQ Bjarne Stroustrup di 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)";

Pemisah adalah urutan yang ditentukan pengguna hingga 16 karakter yang segera mendahului tanda kurung pembuka string mentah literal, dan segera mengikuti tanda kurung penutupnya. Misalnya, dalam R"abc(Hello"\()abc" urutan pemisah adalah abc dan konten string adalah Hello"\(. Anda dapat menggunakan pemisah untuk memisahkan string mentah yang berisi tanda kutip ganda dan tanda kurung. String ini harfiah menyebabkan kesalahan kompilator:

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

Tetapi pemisah menyelesaikannya:

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

Anda dapat membuat literal string mentah yang berisi baris baru (bukan karakter yang lolos) di sumbernya:

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

std::string literals (C++14)

std::string literal adalah implementasi Pustaka Standar dari literal yang ditentukan pengguna (lihat di bawah) yang diwakili sebagai "xyz"s (dengan s akhiran). String literal semacam ini menghasilkan objek sementara jenis std::string, , std::wstring, std::u32stringatau std::u16string, tergantung pada awalan yang ditentukan. Ketika tidak ada awalan yang digunakan, seperti di atas, diproduksi std::string . L"xyz"sstd::wstringmenghasilkan . u"xyz"smenghasilkan std::u16string, dan U"xyz"s menghasilkan 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 };

Akhiran s juga dapat digunakan pada literal string mentah:

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

std::string literal didefinisikan dalam namespace std::literals::string_literals layanan dalam <file header string> . Karena std::literals::string_literals, dan std::literals keduanya dinyatakan sebagai namespace sebaris, std::literals::string_literals secara otomatis diperlakukan seolah-olah itu milik langsung di namespace std.

Ukuran literal string

Untuk string ANSI char* dan pengodean byte tunggal lainnya (tetapi bukan UTF-8), ukuran (dalam byte) dari string literal adalah jumlah karakter ditambah 1 untuk karakter null yang mengakhiri. Untuk semua jenis string lainnya, ukurannya tidak terkait secara ketat dengan jumlah karakter. UTF-8 menggunakan hingga empat char elemen untuk mengodekan beberapa unit kode, dan char16_t atau wchar_t dikodekan sebagai UTF-16 dapat menggunakan dua elemen (dengan total empat byte) untuk mengodekan satu unit kode. Contoh ini menunjukkan ukuran literal string lebar dalam byte:

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

Perhatikan bahwa strlen() dan wcslen() jangan sertakan ukuran karakter null yang mengakhiri, yang ukurannya sama dengan ukuran elemen jenis string: satu byte pada string char* atau char8_t* , dua byte pada wchar_t* atau char16_t* string, dan empat byte pada char32_t* string.

Dalam versi Visual Studio sebelum Visual Studio 2022 versi 17.0, panjang maksimum string literal adalah 65.535 byte. Batas ini berlaku untuk literal string sempit dan literal string lebar. Di Visual Studio 2022 versi 17.0 dan yang lebih baru, pembatasan ini diangkat dan panjang string dibatasi oleh sumber daya yang tersedia.

Memodifikasi literal string

Karena literal string (tidak termasuk std::string harfiah) adalah konstanta, mencoba memodifikasinya—misalnya, str[2] = 'A'—menyebabkan kesalahan kompilator.

Khusus Microsoft

Di Microsoft C++, Anda dapat menggunakan string literal untuk menginisialisasi penunjuk ke non-const char atau wchar_t. Inisialisasi non-const ini diizinkan dalam kode C99, tetapi tidak digunakan lagi di C++98 dan dihapus di C++11. Upaya untuk mengubah string menyebabkan pelanggaran akses, seperti dalam contoh ini:

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

Anda dapat menyebabkan pengkompilasi mengeluarkan kesalahan saat string literal dikonversi ke penunjuk karakter non-const saat Anda mengatur /Zc:strictStrings opsi pengkompilasi (Nonaktifkan konversi jenis literal string). Kami merekomendasikannya untuk kode portabel yang sesuai standar. Ini juga merupakan praktik yang baik untuk menggunakan auto kata kunci untuk mendeklarasikan penunjuk yang diinisialisasi literal string, karena diselesaikan ke jenis yang benar (const). Misalnya, contoh kode ini menangkap upaya untuk menulis ke string literal pada waktu kompilasi:

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

Dalam beberapa kasus, literal string yang identik dapat dikumpulkan untuk menghemat ruang dalam file yang dapat dieksekusi. Dalam pengumpulan string-literal, pengkompilasi menyebabkan semua referensi ke string tertentu harfiah untuk menunjuk ke lokasi yang sama dalam memori, alih-alih memiliki setiap titik referensi ke instans terpisah dari string literal. Untuk mengaktifkan pengumpulan string, gunakan /GF opsi pengkompilasi.

Bagian khusus Microsoft berakhir di sini.

Menggabungkan literal string yang berdekatan

Literal string lebar atau sempit yang berdekatan digabungkan. Deklarasi ini:

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

identik dengan deklarasi ini:

char atr[] = "1234";

dan untuk deklarasi ini:

char atr[] =  "12\
34";

Menggunakan kode escape heksadesimal yang disematkan untuk menentukan literal string dapat menyebabkan hasil yang tidak terduga. Contoh berikut berusaha membuat string literal yang berisi karakter ASCII 5, diikuti oleh karakter f, i, v, dan e:

"\x05five"

Hasil aktual adalah heksadesimal 5F, yang merupakan kode ASCII untuk garis bawah, diikuti oleh karakter i, v, dan e. Untuk mendapatkan hasil yang benar, Anda dapat menggunakan salah satu urutan escape ini:

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

std::stringliteral (dan , , std::u16stringdan ) terkait std::u8stringdapat digabungkan dengan + operator yang ditentukan untuk basic_stringstd::u32stringjenis. Mereka juga dapat digabungkan dengan cara yang sama seperti literal string yang berdekatan. Dalam kedua kasus, pengodean string dan akhiran harus cocok:

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

String literal dengan nama karakter universal

Literal string asli (non-mentah) dapat menggunakan nama karakter universal untuk mewakili karakter apa pun, selama nama karakter universal dapat dikodekan sebagai satu atau beberapa karakter dalam jenis string. Misalnya, nama karakter universal yang mewakili karakter yang diperluas tidak dapat dikodekan dalam string sempit menggunakan halaman kode ANSI, tetapi dapat dikodekan dalam string sempit di beberapa halaman kode multi-byte, atau dalam string UTF-8, atau dalam string lebar. Di C++11, dukungan Unicode diperluas oleh char16_t* jenis string dan char32_t* , dan C++20 memperluasnya ke char8_t jenis :

// 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-)";

Baca juga

Set karakter
Harfiah numerik, Boolean, dan pointer
Literal yang ditentukan pengguna