타입 컨셉은 c++에서 매우 중요하다. 모든 변수, 함수, 인자, 함수 반환값은 반드시 컴파일 되기 위해서 타입을 갖는다. 또한 모든 표현(리터럴 값을 포함한)은 평가되기 전에 컴파일러에 의해서 암묵적으로 타입이 지정된다. 이런 타입의 일부 예에는 정수를 저장하는 int, 부동소수점 값을 저장하는 double(스칼라 데이터 압으로 알려진) 또는 텍스트를 저장하는 표준 라이브러리 클래스 std::basic_string이 있다. 당신은 또한 class 나 struct를 정의하여 자신만의 타입을 만들 수 있다. 타입은 변수에 할당되는 메모리 크기나, 변수에 저장되는 값의 종류, 값이 해석되는 방법 그리고 수행하는 작업을 지정합니다. 이 기사는 c++ 타입 시스템의 주요한 특징에 대한 유용한 개요를 제공합니다.
Terminology
Variable: 데이터 양의 상징적인 이름입니다. 이 이름은 데이터에 접근하기 위해 사용 되는데 이 데이터는 데이터가 저장된 위치의 코드의 모든 범위를 참고합니다. C++에서 변수는 일반적으로 스칼라 데이터 타입 인스턴스를 참조 합니다. 반면에 다른 타입 인스턴스는 보통 오브젝트라고 불립니다.
Object: 단순하고, 일관성을 위해 이 기사는 클래스 또는 구초제 인스턴스를 참조하는 오브젝트 용어를 사용합니다. 그리고 모든 타입을 포함하는 일반적인 의미에서 사용될 때 스칼라 변수 까지도 포함합니다.
POD type: C++에서 정보 카테고리 데이터 압은 스칼라 타입이나, POD 클래스 타입을 참고 합니다. POD 클래스는 정적 데이터와 사용자 정의 생성자, 사용자 정의 소멸자, 사용자 정이 할당 연산자를 갖지 않습니다. 또한 POD 클래스는 가상 함수, 베이스 클래스 그리고 private 또는 protected 논스태틱 데이터 멤버들도 갖지 않습니다. POD 형식은 종종 외부 데이터 교환에 사용 됩니다. 예를 들어 C언어로 작성된 모듈에서.
c++에 리터럴 주요 6개 카테고리가 있습니다. : interger, character, floating-point, string, boolean, and pointer. C++11 부터는 당신은 이러한 카테고리에 기반하는 자신만의 리터럴을 정의 할 수 있다. 이것은 통상적인 관용어에 대한 구문적인 숏컷과 타입 안정성적을 증가 시키기 위한 것이다. 예를 들어 당신은 distance 클래스를 갖고 있다고 말해보자. 당신은 킬로미터와 또다른 마일에 대한 리터럴을 정의할 수 있을 것이다. 그리고 유저들에게 이러한 단위 대해 명확하게 하는 것을 권할 것이다. : auto d = 42.0_km 또는 auto d = 42.0_mi. 사용자 정의 리터럴에 대한 이점과 단점은 없습니다. 이것은 컴파일 타임 형식 추런이나 편의성을 우선적으로 합니다. 이러한 표준 라이브러리는 <chrono> 헤더에 std:;string, std::complex 그리고 시간과 기간 연산 대한 사용자 정의를 갖습니다.
Distance d = 36.0_mi + 42.0_km; // Custom UDL (see below)
std::string str = "hello"s + "World"s; // Standard Library <string> UDL
complex<double> num =
(2.0 + 3.01i) * (5.0 + 4.3i); // Standard Library <complex> UDL
auto duration = 15ms + 42h; // Standard Library <chrono> UDLs
사용자 정의 리터럴 연산 기호
당신은 아래 형식중의 하나로 네임스페이스 범위 에서 operatr""를 이용해서 사용자 정의 리터럴을 구현합니다.
ReturnType operator "" _a(unsigned long long int); // Literal operator for user-defined INTEGRAL literal
ReturnType operator "" _b(long double); // Literal operator for user-defined FLOATING literal
ReturnType operator "" _c(char); // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _d(wchar_t); // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _e(char16_t); // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _f(char32_t); // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _g(const char*, size_t); // Literal operator for user-defined STRING literal
ReturnType operator "" _h(const wchar_t*, size_t); // Literal operator for user-defined STRING literal
ReturnType operator "" _i(const char16_t*, size_t); // Literal operator for user-defined STRING literal
ReturnType operator "" _g(const char32_t*, size_t); // Literal operator for user-defined STRING literal
ReturnType operator "" _r(const char*); // Raw literal operator
template<char...> ReturnType operator "" _t(); // Literal operator template
이전 예제의 연산자 이름은 당신이 제공하는 이름에 대한 플레이스 홀더 입니다. 앞에 언더스코어는 필수 입니다.(표준 라이브러리만 언더스코어 없이 리터럴을 정의하는 것이 가능합니다) 리턴 타입은 당신이 리터럴에 의해 수해오디는 변환이나 다른 연산자를 사용자 정의하는 곳입니다. 또한 이러한 연산들은 constexpr로도 정의될 수 있습니다.
Cooked Literals
소스코드에서 사용자 정의든 아니든 101 or 54.7, "hello", true 와 같은 알파벳 문자들 시퀀스는 필수적이다. 컴파일러는 시퀀스를 integer, float const char* string 등으로 해석한다. 컴파일러 리터럴 값으로 할당한 타입과 상관없이 입력으로 받아드려진 모든 사용자 리터럴 값은 비공식적으로 cook 리터럴로 알려진다. except _r 와 _t 위의 모든 연산자는 cooked literals이다. 예를 들어 리터럴 42.0_kim는 연산자를 _km로 바인드 시킨다. 그것은 _b 시그니처와 유사하다. 그리고 리터럴 42_kim는 연산자를 _a 시그니처와 비슷하게 바인딩 한다.
다음 예제넌 사용자 정의 리터럴이 호출자에게 사용자들의 입력에 대해 명확하게 할 것을 권하는 방법을 보여준다. Distance를 생성하기 위해서 우리는 반드시 kilometers 또는 milds를 적절한 사용자 리터럴을 사용하여 명확히 지정해야 한다. 당신은 다른 방법으로 같은 결과를 얻을 수 있다. 하지만 사용자 정의 리터럴은 다른 대안들 보다 간단한다.
// UDL_Distance.cpp
#include <iostream>
#include <string>
struct Distance
{
private:
explicit Distance(long double val) : kilometers(val)
{}
friend Distance operator"" _km(long double val);
friend Distance operator"" _mi(long double val);
long double kilometers{ 0 };
public:
const static long double km_per_mile;
long double get_kilometers() { return kilometers; }
Distance operator+(Distance other)
{
return Distance(get_kilometers() + other.get_kilometers());
}
};
const long double Distance::km_per_mile = 1.609344L;
Distance operator"" _km(long double val)
{
return Distance(val);
}
Distance operator"" _mi(long double val)
{
return Distance(val * Distance::km_per_mile);
}
int main()
{
// Must have a decimal point to bind to the operator we defined!
Distance d{ 402.0_km }; // construct using kilometers
std::cout << "Kilometers in d: " << d.get_kilometers() << std::endl; // 402
Distance d2{ 402.0_mi }; // construct using miles
std::cout << "Kilometers in d2: " << d2.get_kilometers() << std::endl; //646.956
// add distances constructed with different units
Distance d3 = 36.0_mi + 42.0_km;
std::cout << "d3 value = " << d3.get_kilometers() << std::endl; // 99.9364
// Distance d4(90.0); // error constructor not accessible
std::string s;
std::getline(std::cin, s);
return 0;
}
리터럴 숫자는 반드시 10진수를 사용한다. 그렇지 않으면 숫자는 정수형과 연산자와 호환 불가능한 타입으로 해석될 수 있다. 플로팅 포인 입력에서 타입은 반드시 long double 이여야 한다. 그리고 정수 타입에서는 반드시 longlong 타입이여야 한다.
예시: 로우 리터럴의 한계
로투 리터럴 연산자와 리터럴 연산자 템플릿은 오직 중서나 플로팅 포인트 사용자 정의 리터럴에서만 작동한다. 다른 예시에서 볼수 있듯이
문자열 리터럴은 널이 제거된 문자열을 형성하는 문자들 시퀀스를 함께 표현한다. 문자들은 반드시 쌍따옴표 안에 있어야한다. 다음에 문자열 리터럴의 종류가 있다.
좁은 문자열 리터럴
좁은 무자열 리터럴은 접두사가 없고 쌍따옴표로 구본되고, 널이 제거 된 const char[n] 타입의 배열이다. 여기서 n은 바이트 배열의 길이다. 좁은 문자열 리터럴은 싸따옴표, 백슬래쉬, 또는 개행 문자를 제외한 어떤 그래픽 문자도 포함할 수 있다. 좁은 문자열 리터럴은 또한 아래 정리된 이스케이프 시퀀스와 바이트에 맞는 범용 문자 이름 또한 포함 할수도 있다.
A UTF-8로 인코딩된 문자열은 u8-접두사가 있고, 쌍따옴표로 구분되어 있고 const char[n] 타입의 배열이다. 여기서 n은 인코딩된 바이트 배열의 길이이다. u8 접두사가 있는 문자열 리터럴은 또한 쌍따옴표, 백슬래쉬, 개행문자를 제외하고 어떤 그래픽 문자도 가질 수 있다. u8 접두사가 붙은 문자열 리터럴은 또한 아래 정리된 이스케이프 시퀀스와 어떤 범용 문자 이름을 포함 할수도 있다.
// 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:-)";
넓은 문자열 리터럴
넓은 문자열 리터럴은 널이 없는 wchar_t배열이고 wchar_t는 L 접두사가 붙는다. 그리고 쌍따옴표, 백슬래쉬 또는 개행문자를 제외한 어떤 그래픽 문자든지 포함한다. 넓은 문자열 리터럴은 아래 정리된 이스케이프 문자 시퀀스들과 아무 범용 캐릭터 이름을 포함할 수도 있다.
C++11 은 편한 char16_6(16비트 유니코드)와 char32_t(23비트 유니코드) 문자 타입들을 소개한다.
auto s3 = u"hello"; // const char16_t*
auto s4 = U"hello"; // const char32_t*
raw 문자열 리터럴(C++11)
raw문자열 리터럴은 널이 제거된 아무 문자 타입의 배열이다. 그리고 쌍따옴표, 백슬래쉬 또는 개행문자를 포함하고 아무 그래픽 문자를 포함한다. 로우 문자열 리터럴은 캐릭터 클래스를 사용하는 정규식과 html 문자열, xml 문자열에 사용된다. 샘플에 대한건 다음 기사를 확인 하세요.Bjarne stroustrup's FAQ on C++ 11
구분자는 최대 16문자로 구성된 사용자 정의 시퀀스입니다. 구분자는 로우 스트릴 문자열의 열린 괄호 앞에 있고 그리고 닫힌 과로 뒤에 있습니다. 예를 들어 rR"abc(Hello"\()abc"에서 구분자 시퀀스 이고 문자열 내용은 Hello"\C 입니다. 당신은 당신은 로우 문자열을 명확하게 구분하는 구분자를 사용할수 있습니다. 로우 문자열은 쌍따옴표마크나 광호를 모두 포함합니다. 이런 문자열은 컴파일 에러를 일으킵니다.
// meant to represent the string: )"
const char* bad_parens = R"()")"; // error C2059
그러나 구분자는 이것을 해결합니다.
const char* good_parens = R"xyz()")xyz";
당신은 개행(이스케이프 문자가 아닌)을 포함하는 로우 문자열 리터럴을 구성할 수 있습니다.
std::string 리터럴은 "xyz"s(접미사 s)처럼 표현되는 사용장 정의 리터럴의 표준 라이브러리 구현들이다. 문자열 리터럴 종류는 std::string, std::wstring, std::u32string, 또는 std::u16string과 같은 임시 객체를 생성한다. 이들은 지정된 접두사에 의존적이다. 접두사 없이 사용될 때는 위처럼 std::string이 생성된다. L"xyz"s는 std::wstring을 생성한다. u"xyz"s는 std::u16string를 생성하고 U"xyz"는 std::u32string을 생성한다.
std::string 문자열은 <string> 헤더 파일 안에 std::literals::string_literals 네임스페이스 안에 정의되어 있다. std::literals:;string_literals와 std::literals 모두 인라인 네임스페이스로 선언되어 있기 때문에 std::literals::string_literals는 자동으로 std 네임스페이스에 직접 소유되는 것 처럼 취급됩니다.
문자열 리터럴의 사이즈
ANSI char* 문자열과 기타 단독 바이트 인코딩인 경우, 문자열 리터럴의 크기는 제거 널 문자에서 문자 숫자를 1더한 것이다. 모든 다른 문자열 타입의 경우 크기가 엄격히 문자 갯수와 관련되어 있지는 않다. UTF-8은 일부 코드 유닛을 인코드하기 위해서 char를 4개까지 사용한다. utf-16으로 인코드 된 그리고 char16_t나 wchar_t는 단독 코드 유닛을 인코드 하기 위해서 2개의 요소(총 4바이트)를 사용한다. 이 예제는 넓은 문자열 리터럴의 바이트 사이즈를 보여준다.
strlen()과 scslen()은 종료 널 문자 사이즈를 포함하지 않고 사이즈는 문자열 타입의 요소 사이즈와 동일하다 : char* or char8_t* 문자열은 1바이트, wchar_t* 또는 char16_t* 문자열은 2바이트, char32_t* 문자열은 4바이트.
문자열 리터럴으 최대 길이는 65535 바이트이다. 이 최대치는 좁은 문자열 리터럴과 넓은 문자열 리터럴에 모두 적용된다.
문자열 리터럴 수정
문자열 리터럴(std:;string을 포함하지 않는)는 상수이기 때문에 그것들을 수정하는 것은(예시_str[2] = 'a') 컴파일 에러를 발생 시킨다.
마이크로소프트 관련
C++ 마이크로소프트에서 당신으 non-const char 또는 wchar_t 포인터를 초기화기 위해 사용할 수 있습니다. 이 non-const 초기화는 c99 에서 가능합니다. 하지만 이건 c++98에서 deprecate 됐고, C++11에서 제거 됐습니다. 문자열을 수정하는 시도는 예시처럼 접근 위반을 일으킵니다.
당신은 컴파일 옵션을 /Zc:strictStrings(Disable string literal type conversion)을 설정하고 non-const 문자 포인터로 문자열 리터럴을 번경하려고 하면 콤파일은 에러를 발생합니다. 우리는 표준을 따르는 포터블 코드를 따르는 방법을 추천합니다. 이것은 문자열 리터럴 초기화 포인터를 선언하기 위한 auto 키워드를 사용하는 좋은 연습입니다. 왜냐하면 이것은 정확한 타입으로 해결합니다. 예를 들어 아래 코드 샘플은 컴파일 타임에 문자열 리터럴을 쓰는 시도를 잡아 냅니다.
auto str = L"hello";
str[2] = L'a'; // C3892: you cannot assign to a variable that is const.
어떤 경우에는 실행파일에서 공간을 절약하기 위해 동일한 문자열 리터럴은 풀링된다. 문자열 리터럴 풀링에서 컴파일러는 특정 문자열 리터럴의 모든 참조가 메모리 상의 같은 위치를 가리키게 합니다. 문자열 리터럴에 개별의 인스턴스에 대한 각각의 참조를 갖는 대신에. 문자열 풀링을 하기 위해 컴파일러 옵션 /GF를 사용해라.
마이크로소프트 관련 섹션은 여기서 끝.
인접한 문자열 리터럴의 연결
인접한 넓은 또는 좁은 문자열 리터럴은 연결된다. 여기 선언은:
char str[] = "12" "34";
다음 선언과 동일하다.
char atr[] = "1234";
그리고 이 선언과도 동일하다.
char atr[] = "12\
34";
문자열 리터럴을 지정하기 위해 내장 16진수 이스케이프 코드를 쓰는 것은 예기치 못한 결과를 일으킨다. 다음 예제는 ascii 5 문자를 초함하는 문자열 리터럴을 만들려고 한다. 그 다음 f,i,v 그리고 e를 만듭니다.
"\x05five"
실제 결과는 아스키 코드 언더스코어 16진수 5f 그리고 i, v, e 이다. 정확한 결과를 얻기 위해서는 당신은 이러한 이스케이프 시퀀스중 하나를 사용할 수 있다.
"\005five" // Use octal literal.
"\x05" "five" // Use string splicing.
std::string 리터럴(std::ustring, std::u16string, ste:;u32string과 관련된) 은 basic_string 타입으로 지정된 + 연산자를 통해 연결된다. 그들은 인접한 문자열 리터럴 또한 같은 방식으로 연결된다, 아래 모든 경우, 인코딩 문자열과 접미사는 반드시 매치되어야 한다.
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
범용 문자 이름과 문자열 리터럴
네이티브(raw가 아닌) 문자열 리터럴은 범용 문자 이름이 하나 이상의 문자열 타입으로 인코딩 될수 있는 한 어떤 문자를 표현하기 위해서 범용 캐릭터 문자를 사용할 수도 있습니다. 예를 들어 확장 문자를 표현하는 범용문 자이름은 ansi 코드 페이지를 사용하는 좁은 문자열로 인코딩될 수 었습니다. 그러나 이것은 일부 멀티 바이트 코드 페이지나 utf8문자열 또는 넓은 문자열에서 좁은 문자열로 인코딩 될수 있습니다. c++11에서는 유니코드 서포토는 char16_t 그리고 char32_t 문자열 타입까지 확장되었습니다. 그리고 c++20은 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-)";
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
}
문자열 리터럴은 접두사가 없거나 좁은 범위 문자 utf-8, 넓은 범위 문자 utf16,utf32 인코딩과 같은 제각각의 u8, L, u 접두사를 사용합니다. 저수준 문자열 리터럴은 이러한 인코딩의 저 수준으로 대응되는 r, u8r, lr, ur과 같은 접두사를 갖을 수 있습니다. 임시거나 정적 std::string 값을 만들기 위해서 당신은 문자열 리터럴 또는 저수준 리터럴을 s 접미사와 같이 쓸 수 있습니다. 더 많은 정보는 아래에 String Literals를 보세요. 더 많은 기본 문자열 집합이나 유니버스 문자열 이름, 당신 소스코드에 확장된 코드페이지 캐릭터 사용에 대한 것은 Character sets를 보세요.
Character Literals
캐릭터 리터럴은 상수 캐릭터로 구성됩니다. 이것은 따옴표에 둘러쌓인 문자들로 표현됩니다. 다섯가지 종류의 문자 리터럴이 있습니다.
- char의 오리지널 문자 리터럴, 예시 'a'
- char(C++20에서는 char8_t) 타입의 utf8 문자 리터럴, 예시 u8'a'
- wchar_t 의 넓은 문자 리터럴, 예시 L'a'
- char16_t의 utf-16 문자 리터럴, 예시 u'a'
- char32_t의 utf-32 문자 리터럴, 예시 U'a'
문자 리터럴에 사용되는 문자는 예약된 \,', 뉴라인을 제외하면 어떤 문자도 될수 있다. 예약된 문자들은 이스케이프 시퀀스로 지정될 수 있다. 문자들 범용문자 이름으로 지정된다. 그 타입이 문자를 포함할 만큼 충분히 크다면.
인코딩
문자 리터럴은 그들의 접두사를 기반으로 다르게 인코딩됩니다.
- 접두사가 없는 문자는 오리지널 문자 리터럴 입니다. 문자셋 실행에서 표현되는 싱글 문자나, 이스케이프 문자 또는 범용 문자 이름을 포함하는 문자 리터럴의 오리지널 값은 문자셋 실행에서 인코딩의 숫자값과 동일합니다. 하나 이상 문자, 이스케이프시퀀스 또는 범용 문자 이름을 포함하는 오리지널 문자는 멀티문자 리터럴입니다. 실행 문자 세트에서 표현할 수 없는 멀티 문자 리터럴 또는 일반 문자 리터럴은 type int 와 이며 그 값은 구현 정의 입니다. MSVC에 대해서는 아래 Microsoft-specific section을 보세요.
- 접두사 L로 시작하는 캐릭터 리터럴은 광범위한 문자 리터럴이다. 싱글 문자, 이스케이프 시퀀스, 범용 문자 이름을 포함하는 광범위한 문자 리터럴 값은 문자 리터럴이 와이드 문자셋에서 표현되지 않는한 와이드 캐릭터 문자셋 실행에서 인코딩 수치 값과 동일합니다. 단 이경우 값은 구현정의됩니다.멀티 문자들과 이스케이프 시퀀스 또는 범용 캐릭터 이름을 포함하는 와이드 캐릭터 문자열의 값은 구현정의입니다. MSVC에 대해서는 아래 Microsoft-specific 섹션을 보세요.
- u8 접두사로 시작하는 문자 리터럴은 utf8 문자 리터럴이다. 싱글 문자, 이스케이프 시퀀스 또는 범용 캐릭터 이름을 포함하는 utf8 문자 리터럴 값은 utf8 코드 단독 코드 단위로 표현된다면 iso 10646 코드 포인트와 동일한 값을 갖는다. (C0 Control 과 기본 라틴 유니코드 블록에 해당). 단독 utf8 코드 단위로 표현되지 않는 값은 잘못된 형식입니다. 하나 이상의 문자, 이스케이프 시퀀스, 범용 문자 이름을 포함하는 utf8 문자 리터럴은 잘못된 형식입니다.
- u 접두사로 시작하는 문자 리터럴은 utf16 문자 리터럴이다. 단독 문자, 이스케이프 시퀀스, 또는 범용 캐릭터 이름을 포함하는 utf16값은 iso 10646 코드 포인트와 동등하다. 만약 그것이 단독 utf16코드 단위로 표현되었다면. (기본 멀티 2중 언어 플레인에 대응하는) 만약 그 값이 단독 utf16 코드 단위르롤 표현하지 않는다면 그것은 잘못된 형식이다. 하나의 이상의 문자, 이스케이프 문자열 또는 범용 문자 이름을 포함하는 utf16문자 리터럴은 잘못된 형식이다.
- U 접두사로 시작하는 문자 리터럴은 utf-32 문자 리터럴이다. 단독 문자, 이스케이프 시퀀스, 범용 문자 이름을 포함하는 utf32 문자 리터럴 값은 iso 10646 코드 포인트 값과 동일하다. 하나 이상의 문자, 이스케이프 시퀀스, 범용 문자 이름을 포함하는 utf32 문자 리터럴은 잘못된 형식이다.
Escape sequences
세 종류의 이스케이프 시퀀스가 있다. simple, octal, and hexidecimal. 이스케이프 시퀀스는 다음값 중 하나가 될 수 있다.
newline
\n
backslash
\\
horizontal tab
\t
question mark
? or \?
vertical tab
\v
single quote
\'
backspace
\b
double quote
\"
carriage return
\r
the null character
\0
form feed
\f
octal
\ooo
alert (bell)
\a
hexadecimal
\xhhh
octal 이스케이프 시퀀스는 백슬래쉬 이후의 하나에서 세개의 8진수가 나오는 시퀀스이다. octal 이스케이프 시퀀스는 세번째 진수 전에 8진수가 아닌 문자를 만난다 면 그 처음 문자에서 종료됩니다. 8진수 값의 가장 큰값은 \377입니다.
16진수 이스케이프 시퀀스는 백슬래쉬 다음에 x 그 다음에 하나 이상의 16진수가 옵니다. 앞의 0은 무시된다. 일반문자나 u8 접두사 캐릭터 리터럴에서 최대 16진수 값은 0xFF이다. L 또는 u 넓은 캐릭터 리터럴에서의 최대 16진수 값은 0xFFFF 이다. U 접두사 넓은 캐릭터 맅럴에서 최대 16진수 값은 0xFFFFFF이다.
다음 샘플 코드는 일반문자 리터럴을 사용하는 이스케이프 캐릭터 예제를 보여준다. 다른 문자 리터럴 타입에도 동일한 이스케이프 시퀀스 구분은 유효합니다.
백슬래쉬 문자는 라인 끝에 위치 하면 라인 지속 문자인다. 만약 당신이 백슬래쉬를 캐릭터 리터럴로 표현하길 원한다면 당신은 반드시 행에 2개의 백슬래쉬를 사용해요한다. 라인 지속 문자에 대해 더 알고 싶으면 봐라 Phase of Thranslation
마이크로소프트 관련
좁은 멀티문자 리터럴에서 값을 만들기 위해서는 컴파일러는 문자나 문자 시퀀스를 반점 사이에서 32bit integer에서 8bit로 변경합니다. 리터럴에 멀티 문자는 높은 순에서 낮은순으로 요구되는 바이트에 대응하여 채웁니다. 그리고 컴파일러는 정수형을 보통의 규칙에 따라 목적지 타입으로 변경합니다. 예를 들어 char 값을 만들기 위해서 컴파일러는 낮은 순서의 byte를 갖습니다. 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 시퀀스로 다뤄집니다. 그 다음 진수는 멀티문자 리터럴에 문자로 취급됩니다. 그것은 놀라운 결과를 나타냅니다. 예시.
\377보다 더 큰 8진수 이스케이프 시퀀수는 에러 c2022를 발생합니다. '10진수값":매우 큰 문자.
16진수나 16진수가 아닌 문자를 갖은 것으로 보이는 이스케이프 시퀀스는 마지막 16진수 문자까지 16진수를 포함하는 멀티 문자로 평가됩니다. 16진수를 포함하지 않는 16진수 이스케이프 시퀀스는 컴파일 에러 c2153을 발생 시킵니다. "16진수 리터럴은 반드시 최소한 하나의 16진수를 가져야 한다"
문자 리터럴과 네이티브 문자열 리터럴에서 어떤 문자나 범용 문자 이름을 나타낼 수 있다. 범용 문자 이름은 \U 접두사를 갖고 그 다음 8진수 유니코드 포인트가 오거나 \u접두사를 갖고 그다음 4진수 유니코드 포인트가 오는 형식을 갖는다. 모든 8진수 4진수는 개별적으로 더 나은 유니버셜 문자 이름 형식을 만들기 위해 제시된다.
범용 문자 이름은 대리 코드 포인트 범위 D8000-DFFF에서 값을 인코드 하지 않습니다. 유니코드 대리 쌍에서 특히 \UNNNNNNNN을 사용한 범용문자이름에서 NNNNNNNN은 문자에 대한 8진수 코드 입니다. 컴파일러는 필요하다면 대리 페어를 생성합니다.
C++ 03에서 일부 문자에만 범용문자이름을 나타나 내느 것을 허용 했고 일부 범용문자이름은 실제로 일부 적합한 유니코드 문자들을 표현하는 것이 불가능합니다. 이런 실수는 c++11 기준에 수정되었습니다. C++11에서는 문자 그리고 문자열 리터럴 그리고 식별자까지 모두 범용 문자 이름을 사용할 수 있습니다. 범용문자이름에 대한 더 많은 정보는 CharacterSets을 참고하세요. 유니코드에 대한 정보는 Unicode를 보세요. 대리쌍에 대한 더많은 정보는 Surrogate Pairs and Supplementary Characters를 보세요.
리터럴은 값을 직접 표현하는 프로그램 요소입니다. 이 기사는 interger 타입, 부동소수점, 불리언, 포인터의 리터럴들을 설명합니다. 문자열과 캐릭터 리터럴들에 대한 정보는 여길 String and Character Literals(C++)을 확인하세요. 당신은 또한 이러한 카테고리중에 기초하여 자신의 리터럴을 정의할 수도 있습니다. 더 많은 정보는 User-defined Literals(C++)을 참고하세요.
const int answer = 42; // integer literal
double d = sin(108.87); // floating point literal passed to sin function
bool b = true; // boolean literal
MyClass* mc = nullptr; // pointer literal
때로 컴파일러에게 리터럴을 해석하거나 리터럴에 부여할 특정 유형을 알려주는 것은 중요합니다. 이것은 리터럴의 접두사나 접미사를 붙이면 됩니다. 예를 들어 접두사 0x 는 컴파일레에게 숫자를 16진수 값으로 해석하도록 합니다. (ex example0x35). ULL 접미사는 컴파일레에게 5894345ULL 처럼 unsignedLongLong 값으로 처리하도록 합니다. 각 리터럴 타입의 데한 접두사와 접미사 목록을 알고 싶으면 다음 섹션을 보세요.
Interger Literals
정수형 리터럴은 숫자로 시작되고 분수나 지수 부분이 없습니다. 당신은 정수형 숫자를 십진수, 이진수, 16진수 형태로 지정할 수 있습니다. 당신은 선택적으로 정수형 리터럴을 unsigned 형태로 지정할 수 있고 접미사를 사용하여 long이나 longlong과 같은 타입으로 지정할 수도 있습니다.
접두사, 접미사가 없는 현제 컴파일러는 정수형 리터럴 타입을 int로 지정합니다. 그 값이 맞다면, 그렇지 않으면 long long 타입으로 지정합니다.
십진수 정수형 리터럴로 지정하기 위해서 nonzero digit을 지정하는 것을 시작해라. 예시.
int i = 157; // Decimal literal
int j = 0198; // Not a decimal number; erroneous octal literal
int k = 0365; // Leading zero specifies octal literal, not decimal
int m = 36'000'000 // digit separators make large values more readable
8진수 integral 리터럴로 지정은 0으로 시작하고 그뒤에 0에서 7사이의 숫자가 놓인다. 8과 9는 8진수 리터럴을 지정할 때 에러이다. 아래 예시
int i = 0377; // Octal literal
int j = 0397; // Error: 9 is not an octal digit
16진수 정수 리터럴을 지정하기 위해서는 0x 나 0X로 시작하고(x의 대/소는 상관없음) 뒤에 0에서 9 그리고 a/A에서 f/F 범위 내에서 숫자가 온다. 16진수 a/A ~ f/F는 10~15값을 표현한다. 아래 예시
int i = 0x3fff; // Hexadecimal literal
int j = 0X3FFF; // Equal to i
숫자 구분자 : 당신은 따옴표 문자를 이용하여 사람이 읽기 편하게 커다란 숫자의 공간을 구분할 수 있습니다. 구분자는 컴파일에 아무런 영향을 주지 않습니다.
long long i = 24'847'458'121
부동 소수점 리터럴
부동소수점 리터럴은 분수부분을 같는 값을 지정합니다. 이러한 값들은 소수점(.)을 포함하고 지수를 포함합니다.
부동소수점 리터럴은 숫자의 값을 지정하는 가수를 갖는다. 또한 숫자의 크기를 나타내는 지수부를 갖습니다. 그리고 그들은 선택적인 중위표현식을 갖습니다. 그것은 리터럴 타입을 지정합니다. 가수부는 마침표 앞에오는 숫자들이 거나 숫자의 분을 나타내는 숫자들로 지정됩니다. 아래 예시
18.46
38.
지수는 아래 예제에서와 같이 10의 거듭제급으로 숫자의 크기를 지정합니다
18.46e0 // 18.46
18.46e1 // 184.6
지수는 e 또는 e를 사용하여 지정될 수 있고, 그것들은 같은 의미를 갖습니다. 그 다음에 옵션으로 +또는 -기호와 숫자 순서를 사용할 수 있습니다. 만약 지수가 존재하면 추적하는 소수점은 18E0과 같은 숫자에서 필요 없다.
부동소수점 리터럴은 double 타입을 기본으로 한다. 접미사 f 또는 l 또는 F 또는 L를 (대소문자는 상관없다) 사용하여 리터럴은 float나 longdouble로 지정될 수 있다.
비록 longdouble과 double은 같은 표현을 하지만 그들은 같은 표현이 아니다. 예를 들어 당신은 이와 같이 오버로드 할수 있다.
void func( double );
그리고
void func( long double );
불리언 리터럴
불리언 리터럴은 true와 false이다.
포인터 리터럴(C++11)
C++ 0 초기화 포인터를 지정하는 nullptr을 소개합니다. 유연한 코드에서는 nullptr가 정수형 0이나 매크로 NULL 대신에 사용 되어야합니다.
이진 리터럴(C++14)
이진 리터럴은 0b 나 0B를 사용하여 지정됩니다. 그 다음에 1과 0의 숫자 순서가 업니다.
auto x = 0B001101 ; // int
auto y = 0b000001 ; // int
매직 상수로서의 리터럴을 피하라
당신은 직접적으로 표현식이나 구문을 사용할 수 있다. 비록 그게 항상 좋은 프로그래밍 방식이 아니라고 해도.
if (num < 100)
return "Success";
앞에 예시에서 더 나은 방식은 이름이 있는 상수(명확한 의미를 전달하는)를 사용하는 것이다. 예를 들어 "MAXIMUM_ERROR_THRESHOLD"와 같은. 만약 마지막 사용자가 "Success"라는 리턴 값을 본다면 명명된 문자열 상수를 쓰는게 더 좋을 수 있다. 당신은 다른 언어로 번역가능한 파일의 단독 위치에 문자열 상수를 사용할 수 있다. 명명된 상수를 사용하는것은 당신과 다른 사람들에게 코드의 의도를 이해하는데 도움을 준다.
이미 정의된 키워드는 특별한 의미를 같은 식별자로도 예약되어 있습니다. 그것들은 당신 프로그램에서 식별자들로 사용 될수 없습니다. 아래 마이크로소프트c++에서 예약된 키워드들이 있습니다. c++/cx and c++/cli에 지정된 이름과 언더스코어로 시작하는 이름들은 마이크로소프트 확장입니다.
a 마이크로소프트가 지정한 _asm 키워드는 c++ asm 구문으로 대체 됐습니다. asm 은 다른 c++ 구현과의 호환성을 위해 예약되어 있습니다. 그러나 구현되지 않았습니다. x86 타겟에서 인라인 어셈블리를 위해서 _asm을 사용하세요. 마이크로 소프트는 다른 타겟에서는 인라인 어셈블리를 지원하지 않습니다.
b 확장 연산자 동의어는 permissive 또는 /Za (Disable Language extenstions)가 지정 되었을 때 키워드 입니다. 그들은 마이크로소프트 확장이 가능 했을 때는 키워드가 아닙니다.
c /std:c++ 20 그 이상에 지정된 경우 지원합니다.
Microsoft-specific C++ keywords
C++에서 두개의 연속된 언더스코워를 포함하는 식별자는 컴파일러 구현을 위해 예약된 것입니다. 마이크로소프트 규칙은 마이크로소프트 키워드 앞에 더블 언더스코어를 두는 것 입니다. 이러한 단어는 식별자 이름으로 사용될 수 없다.
마이크로소프트 확장은 기본적으로 사용가능하다. 당신 프로그램이 완전히 호환적이게 하기 위해서는 당신은 컴파일 되는 동안 /eprmisiive or /Za(Diable language extension)의해 지정된 마이크로 소프트 확장기능을 비활성화 해야합니다. 이러한 옵션은 일부 마이크로소프트 관련 키워드를 비활성화 시킬 수 있다.
마이크로소프트 확장기능이 사용가능 할 때, 당신은 당신 프로그램에서 마이크로소프트 관련 키워드를 쓸수 있다. ANSI 준수하기 위해 이러한 키워드 앞에 더블언더스코어가 표시됩니다. 이전 버전과의 호환성을위해 많은 더블언더스코어 키워드의 싱글언더스코어 버전들은 지원됩니다. __cdel 키워드는 선행 언더스코어가 없이 사용 가능합니다.
__asm 키워드는 c++ asm 키워드로 대체 됩니다. asm은 다른 c++ 구현과의 호환성을 위해 예약되어 있습니다. 그러나 구현되어 있지 않습니다. __asm을 사용하세요.