Namespaces
Variants

Character literal

From cppreference.net
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements (loops)
Jump statements
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications ( until C++17* )
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Memory allocation
Classes
Class-specific function properties
Special member functions
Templates
Miscellaneous

목차

구문

' c-char  ' (1)
u8' c-char  ' (2) (C++17부터)
u' c-char  ' (3) (C++11부터)
U' c-char  ' (4) (C++11부터)
L' c-char  ' (5)
' c-char-sequence  ' (6)
L' c-char-sequence  ' (7) (C++23까지)
c-char - 다음 중 하나
basic-c-char - 다음에서 나온 문자 basic source character set (C++23 이전) translation character set (C++23 이후) , 단일 따옴표 ' , 백슬래시 \ , 또는 개행 문자는 제외
c-char-sequence - 두 개 이상의 c-char

설명

1) 일반 문자 리터럴, 예를 들어 'a' 또는 ' \n ' 또는 ' \13 ' . 이러한 리터럴은 char 타입을 가지며 그 값은 실행 문자 집합 내에서 c-char 의 표현 (C++23 이전) 일반 리터럴 인코딩 에서 해당하는 코드 포인트 (C++23 이후) 와 같습니다.
2) UTF-8 문자 리터럴, 예를 들어 u8 'a' . 이러한 리터럴은 char (C++20 이전) char8_t (C++20 이후) 타입을 가지며, 그 값은 ISO/IEC 10646 코드 포인트 값과 동일합니다. 단, 코드 포인트 값이 단일 UTF-8 코드 단위로 표현 가능한 경우(즉, c-char 가 0x0-0x7F 범위 내에 있는 경우)에 한합니다.
3) UTF-16 문자 리터럴, 예를 들어 u '猫' , 하지만 u '🍌' 는 아님 ( u ' \U0001f34c ' ). 이러한 리터럴은 char16_t 타입을 가지며, 그 값은 ISO/IEC 10646 코드 포인트 값과 동일합니다. 단, 코드 포인트 값이 단일 UTF-16 코드 유닛으로 표현 가능한 경우에 한합니다 (즉, c-char 가 0x0-0xFFFF 범위 내에 있는 경우).
4) UTF-32 문자 리터럴, 예를 들어 U '猫' 또는 U '🍌' . 이러한 리터럴은 char32_t 타입을 가지며, 그 값은 ISO/IEC 10646 코드 포인트 값인 c-char 와 동일합니다.
5) 와이드 문자 리터럴, 예를 들어 L 'β' 또는 L '猫' . 이러한 리터럴은 wchar_t 타입을 가지며 그 값은 실행 와이드 문자 세트에서 c-char 의 값 (C++23 이전) 와이드 리터럴 인코딩에서의 해당 코드 포인트 (C++23 이후) 과 같습니다.
6) 일반 다중 문자 리터럴 (C++23 이전) 다중 문자 리터럴 (C++23 이후) , 예를 들어 'AB' 는 조건부 지원되며, 타입은 int 이고 구현 정의 값을 가집니다.
7) 와이드 멀티캐릭터 리터럴, 예를 들어 L 'AB' 는 조건부 지원되며, wchar_t 타입을 가지고 구현 정의 값을 가집니다.

인코딩 불가능한 문자

1-5) 주어진 c-char 가 숫자 이스케이프 시퀀스(아래 참조)가 아니고, c-char 가 리터럴의 관련 문자 인코딩으로 표현 불가능하거나 해당 인코딩에서 단일 코드 단위로 인코딩될 수 없는 경우(예: Windows에서 wchar_t 가 16비트일 때의 비-BMP 값), 프로그램은 ill-formed입니다.
6) 만약 c-char 시퀀스 내의 어떤 c-char ordinary literal encoding 에서 단일 코드 단위로 인코딩될 수 없다면, 프로그램은 ill-formed입니다.
7) 만약 c-char-sequence 내의 어떤 c-char wide literal encoding 에서 단일 코드 단위로 인코딩될 수 없다면, 프로그램은 ill-formed입니다.
(until C++23)

숫자 이스케이프 시퀀스

숫자(8진수 및 16진수) 이스케이프 시퀀스는 문자 값을 지정하는 데 사용할 수 있습니다.

문자 리터럴이 단 하나의 숫자 이스케이프 시퀀스만 포함하고, 이스케이프 시퀀스로 지정된 값이 해당 타입의 부호 없는 버전으로 표현 가능한 경우, 문자 리터럴은 지정된 값과 동일한 값을 가집니다(문자 타입으로 변환된 후일 수 있음).

UTF- N 문자 리터럴은 해당 타입으로 표현 가능한 모든 값을 가질 수 있습니다. 값이 유효한 Unicode 코드 포인트에 해당하지 않거나, 해당 코드 포인트가 UTF- N 에서 단일 코드 단위로 표현 불가능한 경우에도, 해당 값을 가진 숫자 이스케이프 시퀀스로 지정할 수 있습니다. 예를 들어 u8 ' \xff ' 는 형식적으로 올바르며 char8_t ( 0xFF ) 와 동일합니다.

(C++23부터)

일반 문자 리터럴이나 와이드 문자 리터럴에서 사용된 숫자 이스케이프 시퀀스로 지정된 값이 각각 char 또는 wchar_t 로 표현 불가능한 경우, 문자 리터럴의 값은 구현에서 정의된다.

(until C++23)

하나의 c-char 를 갖는 일반 문자 리터럴이나 와이드 문자 리터럴에서 사용된 숫자 이스케이프 시퀀스로 지정된 값이 각각 char 또는 wchar_t 의 기반 타입(unsigned version)으로 표현 가능한 경우, 리터럴의 값은 해당 부호 없는 정수 타입의 정수 값이며 지정된 값이 리터럴의 타입으로 변환된 값이다. 그렇지 않으면 프로그램은 ill-formed이다.

(since C++23)

UTF- N 문자 리터럴에서 사용된 숫자 이스케이프 시퀀스로 지정된 값이 해당 char N _t 로 표현 불가능한 경우, 문자 리터럴의 값은 구현체 정의입니다 (C++17까지) 프로그램은 ill-formed입니다 (C++17부터) .

(C++11부터)

참고 사항

멀티캐릭터 리터럴은 B 프로그래밍 언어에서 C로 상속되었습니다. C나 C++ 표준에 명시되어 있지 않지만, 대부분의 컴파일러(MSVC는 주목할 만한 예외입니다)는 B에서 명시된 대로 멀티캐릭터 리터럴을 구현합니다: 리터럴 내 각 char의 값은 빅 엔디안, 제로 패딩, 우측 정렬 순서로 결과 정수의 연속된 바이트를 초기화합니다. 예를 들어, ' \1 ' 의 값은 0x00000001 이고, ' \1 \2 \3 \4 ' 의 값은 0x01020304 입니다.

C 언어에서, 'a' 또는 ' \n ' 와 같은 문자 상수는 char 가 아닌 int 타입을 가집니다.

예제

#include <cstdint>
#include <iomanip>
#include <iostream>
#include <string_view>
template<typename CharT>
void dump(std::string_view s, const CharT c)
{
    const uint8_t* data{reinterpret_cast<const uint8_t*>(&c)};
    std::cout << s << " \t" << std::hex
              << std::uppercase << std::setfill('0');
    for (auto i{0U}; i != sizeof(CharT); ++i)
        std::cout << std::setw(2) << static_cast<unsigned>(data[i]) << ' ';
    std::cout << '\n';
}
void print(std::string_view str = "") { std::cout << str << '\n'; }
int main()
{
    print("Ordinary character literals:");
    char c1 = 'a'; dump("'a'", c1);
    char c2 = '\x2a'; dump("'*'", c2);
    print("\n" "Ordinary multi-character literals:");
    int mc1 = 'ab'; dump("'ab'", mc1);       // implementation-defined
    int mc2 = 'abc'; dump("'abc'", mc2);     // implementation-defined
    print("\n" "UTF-8 character literals:");
    char8_t C1 = u8'a'; dump("u8'a'", C1);
//  char8_t C2 = u8'¢'; dump("u8'¢'", C2);   // error: ¢ maps to two UTF-8 code units
//  char8_t C3 = u8'猫'; dump("u8'猫'", C3); // error: 猫 maps to three UTF-8 code units
//  char8_t C4 = u8'🍌'; dump("u8'🍌'", C4); // error: 🍌 maps to four UTF-8 code units
    print("\n" "UTF-16 character literals:");
    char16_t uc1 = u'a'; dump("u'a'", uc1);
    char16_t uc2 = u'¢'; dump("u'¢'", uc2);
    char16_t uc3 = u'猫'; dump("u'猫'", uc3);
//  char16_t uc4 = u'🍌'; dump("u'🍌'", uc4); // error: 🍌 maps to two UTF-16 code units
    print("\n" "UTF-32 character literals:");
    char32_t Uc1 = U'a'; dump("U'a'", Uc1);
    char32_t Uc2 = U'¢'; dump("U'¢'", Uc2);
    char32_t Uc3 = U'猫'; dump("U'猫'", Uc3);
    char32_t Uc4 = U'🍌'; dump("U'🍌'", Uc4);
    print("\n" "Wide character literals:");
    wchar_t wc1 = L'a'; dump("L'a'", wc1);
    wchar_t wc2 = L'¢'; dump("L'¢'", wc2);
    wchar_t wc3 = L'猫'; dump("L'猫'", wc3);
    wchar_t wc4 = L'🍌'; dump("L'🍌'", wc4);  // unsupported on Windows since C++23
}

가능한 출력:

Ordinary character literals:
'a' 	61 
'*' 	2A 
Ordinary multi-character literals:
'ab' 	62 61 00 00 
'abc' 	63 62 61 00 
UTF-8 character literals:
u8'a' 	61 
UTF-16 character literals:
u'a' 	61 00 
u'¢' 	A2 00 
u'猫' 	2B 73 
UTF-32 character literals:
U'a' 	61 00 00 00 
U'¢' 	A2 00 00 00 
U'猫' 	2B 73 00 00 
U'🍌' 	4C F3 01 00 
Wide character literals:
L'a' 	61 00 00 00 
L'¢' 	A2 00 00 00 
L'猫' 	2B 73 00 00 
L'🍌' 	4C F3 01 00

결함 보고서

다음의 동작 변경 결함 보고서들은 이전에 발표된 C++ 표준에 소급 적용되었습니다.

DR 적용 대상 게시된 동작 올바른 동작
CWG 912 C++98 인코딩 불가능한 일반 문자 리터럴이 명시되지 않음 조건부 지원으로 명시됨
CWG 1024 C++98 다중 문자 리터럴이 지원되어야 함 조건부 지원으로 변경됨
CWG 1656 C++98 문자 리터럴 내 숫자 이스케이프 시퀀스의 의미가 불명확함 명시됨
P1854R4 C++98 인코딩 불가능한 문자 리터럴이 조건부 지원됨 프로그램이 비형식적(ill-formed)임

참고문헌

  • C++23 표준 (ISO/IEC 14882:2024):
  • 5.13.3 문자 리터럴 [lex.ccon]
  • C++20 표준(ISO/IEC 14882:2020):
  • 5.13.3 문자 리터럴 [lex.ccon]
  • C++17 표준(ISO/IEC 14882:2017):
  • 5.13.3 문자 리터럴 [lex.ccon]
  • C++14 표준(ISO/IEC 14882:2014):
  • 2.14.3 문자 리터럴 [lex.ccon]
  • C++11 표준(ISO/IEC 14882:2011):
  • 2.14.3 문자 리터럴 [lex.ccon]
  • C++03 표준(ISO/IEC 14882:2003):
  • 2.13.2 문자 리터럴 [lex.ccon]
  • C++98 표준(ISO/IEC 14882:1998):
  • 2.13.2 문자 리터럴 [lex.ccon]

참고 항목

사용자 정의 리터럴 (C++11) 사용자 정의 접미사를 가진 리터럴
C 문서 for 문자 상수