文字列リテラルと文字リテラル (C++)

C++ はさまざまな文字列と文字型をサポートし、これらの型のリテラル値を表す方法を提供しています。 ソース コードでは、文字セットを使用して文字リテラルと文字列リテラルの内容を表現します。 ユニバーサル文字名とエスケープ文字を使用すると、基本ソース文字セットのみを使用してあらゆる文字列を表現できます。 未加工文字列リテラルを使用すると、エスケープ文字の使用を避けられるとともに、全種類の文字列リテラルを表すことができます。 また、追加の std::string 構築または変換手順を実行することなく、リテラルを作成できます。

#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*, encoded as UTF-8
    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*, encoded as UTF-8
    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
    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*, encoded as UTF-8
    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
}

文字列リテラルは、プレフィックスを省略することも、 u8Lu、または U プレフィックスを使用することもできます。これらは、それぞれ、ナロー文字 (単一バイトまたは複数バイト)、UTF-8、ワイド文字 (UCS-2 または UTF-16)、UTF-16、UTF-32 エンコーディングを表します。 生の文字列リテラルには、これらのエンコードと同等の未加工バージョンのプレフィックス、 R u8R および LR uR UR を指定できます。 一時値または静的値を作成するには、サフィックス付き文字列リテラルまたは std::string 生文字列リテラルを使用 s できます。 詳細については、以下の「 文字列リテラル」セクションを 参照してください。 基本的なソース文字セット、ユニバーサル文字名、およびソース コード内の拡張コード ページからの文字の使用の詳細については、「文字セット」を 参照してください

文字リテラル

文字リテラル は、定数文字で構成されます。 これは、単一引用符で囲まれた文字で表されます。 文字リテラルには、次の 5 種類があります。

  • 型の通常の文字リテラル char (例: ) 'a'

  • 型の UTF-8 文字リテラル char ( char8_t C++20 の場合) など u8'a'

  • 型のワイド文字リテラル wchar_t (例: ) L'a'

  • 型の UTF-16 文字リテラル char16_t (例: ) u'a'

  • 型の UTF-32 文字リテラル char32_t (例: ) U'a'

文字リテラルに使用される文字は、予約文字の円記号 ( )、単一引用符 ( )、または改行を除き、任意の文字 \ ' になります。 予約文字は、エスケープ シーケンスを使用して指定することができます。 型が文字を保持するのに十分な大きさであれば、文字はユニバーサル文字名を使用して指定することができます。

Encoding

文字リテラルは、プレフィックスに基づいて異なる方法でエンコードされます。

  • プレフィックスのない文字リテラルは、通常の文字リテラルです。 実行文字セットで表される 1 つの文字、エスケープ シーケンス、またはユニバーサル文字名を含む通常の文字リテラルの値は、実行文字セット内のエンコードの数値と等しい値を持っています。 複数の文字、エスケープ シーケンス、またはユニバーサル文字名を含む通常の文字リテラルは、 マルチ文字リテラル です。 実行文字セットで表現できないマルチ文字リテラルまたは通常の文字リテラルは 型で、その値は実装 int 定義です。 詳細MSVC、以下の Microsoft 固有 のセクションを 参照してください。

  • プレフィックスで始まる文字リテラル L はワイド文字リテラルです。 1 文字、エスケープ シーケンス、またはユニバーサル文字名を含むワイド文字リテラルの値は、実行ワイド文字セット内のエンコードの数値と等しい値を持っています。この場合、文字リテラルに実行ワイド文字セットの表現がない限り、値は実装定義です。 複数の文字、エスケープ シーケンス、またはユニバーサル文字名を含むワイド文字リテラルの値は、実装定義です。 詳細MSVC、以下の Microsoft 固有 のセクションを 参照してください。

  • プレフィックスで始まる文字リテラル u8 は、UTF-8 文字リテラルです。 1 つの文字、エスケープ シーケンス、またはユニバーサル文字名を含む UTF-8 文字リテラルの値は、単一の UTF-8 コードユニット (C0 Controls および Basic Latin Unicode ブロックに対応) で表される場合、ISO 10646 コード ポイント値と等しい値になります。 値を 1 つの UTF-8 コード単位で表できない場合、プログラムの形式が不正です。 複数の文字、エスケープ シーケンス、またはユニバーサル文字名を含む UTF-8 文字リテラルの形式が不正です。

  • プレフィックスで始まる文字リテラル u は、UTF-16 文字リテラルです。 単一の文字、エスケープ シーケンス、またはユニバーサル文字名を含む UTF-16 文字リテラルの値は、単一の UTF-16 コード単位 (基本的な多言語プレーンに対応) で表される場合、その ISO 10646 コード ポイント値と等しい値になります。 値を 1 つの UTF-16 コードユニットで表できない場合、プログラムの形式が不正です。 複数の文字、エスケープ シーケンス、またはユニバーサル文字名を含む UTF-16 文字リテラルの形式が不正です。

  • プレフィックスで始まる文字リテラル U は、UTF-32 文字リテラルです。 1 つの文字、エスケープ シーケンス、またはユニバーサル文字名を含む UTF-32 文字リテラルの値は、その ISO 10646 コード ポイント値と等しい値を持っています。 複数の文字、エスケープ シーケンス、またはユニバーサル文字名を含む UTF-32 文字リテラルの形式が不正です。

エスケープ シーケンス

エスケープ シーケンスには、単純、8 進数、16 進数という 3 つの種類があります。 エスケープ シーケンスには、次の値を指定できます。

エスケープ シーケンス
改行 \n
円記号 \\
水平タブ \t
疑問符 ? または \?
垂直タブ \V
単一引用符 (') \'
バックスペース \B
二重引用符 (") \"
キャリッジ リターン \R
null 文字 \0
フォーム フィード \F
8 進数 \ooo
警告 (ベル) \a
16 進数 \xhhh

8 進数のエスケープ シーケンスは、円記号の後に 1 ~ 3 桁の 8 進数のシーケンスです。 8 進数のエスケープ シーケンスは、3 番目の数字より早く発生した場合、8 進数ではない最初の文字で終了します。 考えられる最大の 8 進数の値は です \377

16 進数のエスケープ シーケンスは、円記号の後に 文字 が続き、1 つ以上の 16 進数の x シーケンスです。 先行 0 は無視されます。 通常または u8 プレフィックスの文字リテラルでは、最大の 16 進数の値は0xFF。 L プレフィックス付きまたは u プレフィックス付きワイド文字リテラルでは、最大の 16 進値は 0xFFFF です。 U プレフィックス付きワイド文字リテラルでは、最大の 16 進値は 0xFFFFFFFF です。

このサンプル コードは、通常の文字リテラルを使用したエスケープ文字の例を示しています。 他の文字リテラル型でも、同じエスケープ シーケンス構文が有効です。

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

円記号 ( ) は、行の末尾に配置される行継続 \ 文字です。 円記号を文字リテラルとして表示する場合は、2 つの円記号を行 ( ) に入力する必要があります \\ 。 行連結文字について詳しくは、「 Phases of Translation」をご覧ください。

Microsoft 固有の仕様

ナロー マルチ文字リテラルから値を作成するために、コンパイラは文字または文字シーケンスを単一引用符間で 32 ビット整数内の 8 ビット値に変換します。 リテラル内の複数の文字に対応するバイトが、必要に応じて、上位から下位に入力されます。 コンパイラは、通常の規則に従って、整数を変換先の型に変換します。 たとえば、値を作成 char するために、コンパイラは低い順序のバイトを受け取います。 または 値を wchar_t 作成 char16_t するために、コンパイラは低い順序の単語を受け取る。 割り当てられたバイトまたはワードを上回るビットが設定された場合、コンパイラは結果が切り捨てられることを警告します。

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

3 桁を超える数字を含むと思われる 8 進数のエスケープ シーケンスは、3 桁の 8 進数のシーケンスとして扱われます。その後、後続の数字はマルチ文字リテラル内の文字として扱われます。これは、驚くべき結果を生み出す可能性があります。 次に例を示します。

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

8 進数以外の文字を含むと思えるエスケープ シーケンスは、最後の 8 進数文字までの 8 進数のシーケンスとして評価され、その後に残りの文字がマルチ文字リテラルの後続の文字として評価されます。 Warning C4125 は、8進数以外の最初の文字が10進数の場合に生成されます。 次に例を示します。

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

値が大きい8進数のエスケープシーケンスは、 \377 エラー C2022: '値-in-decimal': 文字に対して大きすぎます。

16進数と16進数以外の文字を含むエスケープシーケンスは、最後の16進数文字までの16進数のエスケープシーケンスと、それに続く16進数以外の文字が含まれる多文字リテラルとして評価されます。 16進数字を含まない16進数のエスケープシーケンスでは、コンパイラエラーいう c2153: "16 進数リテラルには少なくとも1つの16進数が必要です" が発生します。

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

で始まるワイド文字リテラルに L 多文字シーケンスが含まれている場合は、最初の文字から値が取得され、コンパイラによって警告 C4066 が生成されます。 同等の通常の多文字リテラルの動作とは異なり、後続の文字は無視されます。

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

Microsoft 固有 のセクションはここで終了します。

ユニバーサル文字名

文字リテラルとネイティブ (未加工ではない) 文字列リテラルでは、ユニバーサル文字名であらゆる文字を表すことができます。 ユニバーサル文字名は、プレフィックスの \U 後に8桁の unicode コードポイントが続く形式、またはプレフィックスの \u 後に4桁の unicode コードポイントが続く形式によって形成されます。 正しい形式のユニバーサル文字名を作成するには、それぞれ、8 桁または 4 桁のすべてが存在する必要があります。

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'

サロゲート ペア

ユニバーサル文字名は、サロゲートコードポイント範囲 D800 内の値をエンコードできません-DFFF。 Unicode サロゲート ペアの場合は、 \UNNNNNNNNを使用してユニバーサル文字名を指定します。ここで、NNNNNNNN は文字用の 8 桁のコード ポイントです。 必要に応じて、コンパイラによってサロゲートペアが生成されます。

C++03 では、ユニバーサル文字名で表現できたのは文字のサブセットに過ぎず、許可されていた一部のユニバーサル文字名は実際には正しい Unicode 文字を表していませんでした。 この誤りは、C++ 11 標準で修正されました。 C++11 では、文字リテラルと文字列リテラルの両方と識別子でユニバーサル文字名を使用できます。 ユニバーサル文字名について詳しくは、「 Character Sets」をご覧ください。 Unicode について詳しくは、「 Unicode」をご覧ください。 サロゲート ペアについて詳しくは、「 サロゲート ペアと補助文字」をご覧ください。

文字列リテラル

文字列リテラルは文字のシーケンスを表し、その全体が、null で終わる文字列を形成します。 文字列は二重引用符で囲む必要があります。 文字列リテラルの種類は次のとおりです。

ナロー文字列リテラル

ナロー文字列リテラルは、プレフィックスのない二重引用符で区切られ、null で終わる型の配列です const char[n] 。ここで、n は配列の長さ (バイト単位) です。 ナロー文字列リテラルには、二重引用符 (")、円記号 (\)、または改行文字を除く、任意のグラフィック文字を含めることができます。 ナロー文字列リテラルには、上記のエスケープ シーケンスと、1 バイトに収まるユニバーサル文字名を含めることもできます。

const char *narrow = "abcd";

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

UTF-8 でエンコードされた文字列

UTF-8 でエンコードされた文字列は、u8 プレフィックスが付いた、二重引用符で区切られ、null で終わる型の配列です const char[n] 。ここで、 n は、エンコードされた配列の長さ (バイト単位) です。 u8 プレフィックス付き文字列リテラルには、二重引用符 (")、円記号 (\)、または改行文字を除く、任意のグラフィック文字を含めることができます。 u8 プレフィックス付き文字列リテラルには、上記のエスケープ シーケンスと、任意のユニバーサル文字名を含めることもできます。

const char* str1 = u8"Hello World";
const char* str2 = u8"\U0001F607 is O:-)";

ワイド文字列リテラル

ワイド文字列リテラルは、null で終わる定数の配列であり、 wchar_t ' ' というプレフィックスが L 付けられ、二重引用符 ( " )、円記号 ( \ )、または改行文字を除く任意のグラフィック文字が含まれます。 ワイド文字列リテラルには、上記のエスケープ シーケンスと、任意のユニバーサル文字名を含めることができます。

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

char16_t および char32_t (C++11)

C++ 11 では、移植可能 char16_t な (16 ビット unicode) char32_t 文字型と (32 ビット unicode) 文字型が導入されています。

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

未加工の文字列リテラル (C++ 11)

未加工文字列リテラルは、任意の文字型の null で終わる配列で、二重引用符 ( " )、円記号 ( \ )、または改行文字を含む任意のグラフィック文字で構成されます。 未加工文字列リテラルは、文字クラスを使用する正規表現や、HTML 文字列、XML 文字列でよく使用されます。 例については、記事「 C++11 に関する Bjarne Stroustrup の FAQ」をご覧ください。

// 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_utf8  = u8R"(An unescaped \ character)";
const char16_t* raw_utf16 = uR"(An unescaped \ character)";
const char32_t* raw_utf32 = UR"(An unescaped \ character)";

区切り記号は、16文字までのユーザー定義シーケンスで、未加工の文字列リテラルの始めかっこの直前にあり、終わりかっこの直後に続きます。 たとえば、 R"abc(Hello"\()abc" では、区切り記号シーケンスが abc で、文字列コンテンツが Hello"\(です。 区切り記号を使用することで、二重引用符とかっこの両方を含む未加工の文字列の曖昧さを解消できます。 この文字列リテラルでは、コンパイラエラーが発生します。

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

しかし、区切り文字を使用することで、エラーは解決します。

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

次のように、ソースの改行 (エスケープ文字ではない) を含む未加工の文字列リテラルを作成できます。

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

std:: string リテラル (C++ 14)

std::string リテラルは、 "xyz"s (サフィックス付きで) として表されるユーザー定義リテラルの標準ライブラリ実装です (下記参照) s 。 この種類の文字列リテラルでは、指定され std::stringstd::wstring std::u32string プレフィックスに応じて、、、、または型の一時オブジェクトが生成 std::u16string されます。 プレフィックスが使用されていない場合、上記のように、 std::string が生成されます。 L"xyz"s を生成 std::wstring します。 u"xyz"s std: : u16stringを生成し、 U"xyz"s std:: u32stringを生成します。

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

この s サフィックスは、未加工の文字列リテラルでも使用できます。

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

std::string リテラルは、ヘッダーファイルの名前空間で定義されてい std::literals::string_literals <string> ます。 std::literals::string_literalsstd::literals は両方ともインライン名前空間として宣言されているため、 std::literals::string_literals は名前空間に直接属しているかのように自動的に処理され std ます。

文字列リテラルのサイズ

ANSI char* 文字列およびその他の1バイトエンコーディング (utf-8 ではない) では、文字列リテラルのサイズ (バイト単位) は、終端の null 文字の文字数に1を加えた値になります。 その他のすべての文字列型では、サイズが文字数と厳密に関連していません。 UTF-8 では、最大4つの要素を使用して char 一部の コード単位 をエンコードし char16_t wchar_t ます。また、utf-16 としてエンコードすると、1つの コード単位 をエンコードするために2つの要素 (合計4バイト) が使用されます。 この例では、ワイド文字列リテラルのサイズがバイト単位で表示されます。

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

とには、 strlen() 終端の null 文字のサイズが含まれていないことに注意して wcslen() ください。サイズが文字列型の要素サイズと同じであるか、文字列または文字列に char* char8_t* 2 バイト、 wchar_t* char16_t* 文字列に4バイト char32_t* が格納されます。

文字列リテラルの最大長は65535バイトです。 この制限は、ナローとワイドの両方の文字列リテラルに適用されます。

文字列リテラルの変更

文字列リテラル ( std::string リテラルは含まない) は定数であるため、変更しようとすると (など)、 str[2] = 'A' コンパイラエラーが発生します。

Microsoft 固有の仕様

Microsoft C++ では、文字列リテラルを使用して、非 const またはへのポインターを初期化でき char wchar_t ます。 この非定数初期化は C99 コードで許可されていますが、C++ 98 では非推奨とされており、C++ 11 では削除されています。 文字列を変更すると、この例のようにアクセス違反が発生します。

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

/Zc:strictStrings (文字列リテラル型の変換を無効にする)コンパイラオプションを設定したときに、文字列リテラルが非 const 文字ポインターに変換されたときに、コンパイラからエラーが出力されるようにすることができます。 標準に準拠した移植可能なコードの場合にこれをお勧めします。 また、キーワードを使用して、文字列リテラルに初期化されたポインターを宣言することをお勧めし auto ます。これは、正しい (const) 型に解決されるためです。 たとえば、このコード例ではコンパイル時に文字列リテラルへの書き込みの試みがキャッチされます。

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

場合によっては、実行可能ファイルの領域を節約するために、同じ文字列リテラルをプールできます。 文字列リテラルのプールでは、各参照が文字列リテラルの各インスタンスを指すのではなく、コンパイラにより、特定の文字列リテラルへのすべての参照がメモリ内の同じ場所を指します。 文字列プールを有効にするには、コンパイラオプションを使用し /GF ます。

Microsoft 固有 のセクションはここで終了します。

隣接する文字列リテラルの連結

隣接するワイド文字列リテラルまたはナロー文字列リテラルは連結されます。 次の宣言は、

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

次の宣言と同じです。

char atr[] = "1234";

次の宣言も同じです。

char atr[] =  "12\
34";

埋め込みの 16 進数エスケープ コードを使用して文字列リテラルを指定すると、予期しない結果が生じることがあります。 次の例では、ASCII 文字 5 の後に文字列 f、i、v、および e を含む文字列リテラルを作成しようとしています。

"\x05five"

実際の結果は、16 進数値 5F (アンダースコアの ASCII コード) に文字列 i、v、および e が続きます。 正しい結果を得るには、次のいずれかのエスケープシーケンスを使用します。

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

std::string リテラルは std::string 型であるため、 + 型に対して定義されている演算子と連結でき basic_string ます。 隣接する文字列リテラルと同じ方法で連結することもできます。 いずれの場合も、次のように文字列のエンコードとサフィックスは一致していなければなりません。

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

ユニバーサル文字名を持つ文字列リテラル

ネイティブ (未加工でない) 文字列リテラルは、ユニバーサル文字名が文字列型の 1 つ以上の文字としてエンコードできる限り、ユニバーサル文字名を使用して任意の文字を表すことができます。 たとえば、拡張文字を表すユニバーサル文字名は、ANSI コードページを使用してナロー文字列でエンコードすることはできませんが、一部のマルチバイトコードページ、UTF-8 文字列、またはワイド文字列では、ナロー文字列でエンコードすることができます。 C++ 11 では、Unicode のサポートはとの文字列型によって拡張されてい char16_t* char32_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*     s3 = u8"😇 = \U0001F607 is O:-)";

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

関連項目

文字セット
数値、ブール値、およびポインターのリテラル
ユーザー定義リテラル