User-defined literals (since C++11)

사용자 정의 접미사를 정의하여 정수, 부동 소수점, 문자 및 문자열 리터럴이 사용자 정의 타입의 객체를 생성할 수 있도록 합니다.

구문

사용자 정의 리터럴은 다음 형태 중 하나의 표현식입니다

토큰이 사용자 정의 리터럴 구문과 일반 리터럴 구문 모두와 일치하는 경우, 해당 토큰은 일반 리터럴로 간주됩니다(즉, LL 을 123LL 에서 오버로드하는 것은 불가능합니다).

컴파일러가 사용자 정의 리터럴을 ud-suffix X 와 함께 만나면, 비정규 이름 조회 를 수행하여 operator "" X 라는 이름의 함수를 찾습니다. 조회가 선언을 찾지 못하면 프로그램은 잘못된 형식입니다. 그렇지 않은 경우,

long double operator ""_w(long double);
std::string operator ""_w(const char16_t*, size_t);
unsigned    operator ""_w(const char*);
int main()
{
    1.2_w;    // operator ""_w(1.2L) 호출
    u"one"_w; // operator ""_w(u"one", 3) 호출
    12_w;     // operator ""_w("12") 호출
    "two"_w;  // 오류: 적용 가능한 리터럴 연산자가 없음
}

문자열 리터럴 연결이 번역 단계 6 에서 발생할 때, 사용자 정의 문자열 리터럴들도 함께 연결되며, 연결된 리터럴들 전체에 단 하나의 접미사만 나타날 수 있다는 점을 제외하고는 연결 목적상 그들의 ud-suffix 들은 무시됩니다:

int main()
{
    L"A" "B" "C"_x;  // OK: L"ABC"_x와 동일함
    "P"_x "Q" "R"_y; // 오류: 두 개의 다른 사용자 정의 접미사(_x와 _y)
}

리터럴 연산자

사용자 정의 리터럴에 의해 호출되는 함수는 literal operator (또는 템플릿인 경우 literal operator template )로 알려져 있습니다. 이는 네임스페이스 범위에서 다른 function 또는 function template 와 마찬가지로 선언됩니다(이는 friend function, 함수 템플릿의 명시적 인스턴스화 또는 특수화, 혹은 using-declaration에 의해 도입될 수도 있습니다). 단, 다음과 같은 제한 사항이 적용됩니다:

이 함수의 이름은 두 가지 형태 중 하나를 가질 수 있습니다:

ud-suffix 는 밑줄 _ 로 시작해야 합니다: 밑줄로 시작하지 않는 접미사는 표준 라이브러리에서 제공하는 리터럴 연산자를 위해 예약되어 있습니다. 또한 이중 밑줄 __ 을 포함할 수 없습니다: 이러한 접미사 역시 예약되어 있습니다.

리터럴 연산자가 템플릿인 경우, 빈 매개변수 목록을 가져야 하며 하나의 템플릿 매개변수만 가질 수 있습니다. 이 매개변수는 요소 타입이 char 인 상수 템플릿 매개변수 팩이어야 합니다 (이 경우 numeric literal operator template 으로 알려져 있습니다):

template<char...>
double operator ""_x();

struct A { constexpr A(const char*); };
template<A a>
A operator ""_a();

리터럴 연산자에는 다음 매개변수 목록만 허용됩니다:

기본 인수 는 허용되지 않습니다.

C language linkage 는 허용되지 않습니다.

위의 제한 사항을 제외하면, 리터럴 연산자와 리터럴 연산자 템플릿은 일반 함수(및 함수 템플릿)이며, inline이나 constexpr로 선언될 수 있고, 내부 또는 외부 링크를 가질 수 있으며, 명시적으로 호출될 수 있고, 주소를 취할 수 있습니다 등.

#include <string>
void        operator ""_km(long double); // OK, 1.0_km에 대해 호출됨
void        operator "" _km(long double); // 위와 동일, 사용 권장되지 않음
std::string operator ""_i18n(const char*, std::size_t); // OK
template<char...>
double operator ""_pi(); // OK
float  operator ""_e(const char*); // OK
// 오류: 접미사는 밑줄로 시작해야 함
float operator ""Z(const char*);
// 오류: 밑줄로 시작하고 대문자가 뒤따르는 모든 이름은 예약됨
// (참고: ""와 _ 사이에 공백이 있음)
double operator"" _Z(long double);
// OK. 참고: ""와 _ 사이에 공백 없음
double operator""_Z(long double);
// OK: 리터럴 연산자는 오버로드 가능
double operator ""_Z(const char* args);
int main() {}

참고 사항

사용자 정의 리터럴이 도입된 이후, 앞선 문자열 리터럴 뒤에 공백 없이 고정 너비 정수 타입에 대한 형식 매크로 상수 를 사용하는 코드는 유효하지 않게 되었습니다: std:: printf ( "%" PRId64 " \n " , INT64_MIN ) ; 는 다음으로 대체되어야 합니다: std:: printf ( "%" PRId64 " \n " , INT64_MIN ) ; .

최대한 많이 인식(maximal munch) 규칙으로 인해, p , P , (C++17부터) e 및 E 로 끝나는 사용자 정의 정수 및 부동 소수점 리터럴은 + 또는 - 연산자가 뒤따를 경우, 소스 코드에서 공백이나 괄호로 연산자와 분리해야 합니다:

long double operator""_E(long double);
long double operator""_a(long double);
int operator""_p(unsigned long long);
auto x = 1.0_E+2.0;   // 오류
auto y = 1.0_a+2.0;   // 정상
auto z = 1.0_E +2.0;  // 정상
auto q = (1.0_E)+2.0; // 정상
auto w = 1_p+2;       // 오류
auto u = 1_p +2;      // 정상

정수나 부동소수점 사용자 정의 리터럴 뒤에 오는 점 연산자에도 동일하게 적용됩니다:

#include <chrono>
using namespace std::literals;
auto a = 4s.count();   // 오류
auto b = 4s .count();  // 정상
auto c = (4s).count(); // 정상

그렇지 않으면 단일 유효하지 않은 전처리 숫자 토큰(예: 1.0 _E + 2.0 또는 4s. count )이 생성되어 컴파일이 실패하게 됩니다.

키워드

operator

예제

#include <algorithm>
#include <cstddef>
#include <iostream>
#include <numbers>
#include <string>
// 입력 파라미터인 도(degrees)를 라디안(radians)으로 변환하는 용도
constexpr long double operator""_deg_to_rad(long double deg)
{
    long double radians = deg * std::numbers::pi_v<long double> / 180;
    return radians;
}
// 사용자 정의 타입과 함께 사용
struct mytype
{
    unsigned long long m;
};
constexpr mytype operator""_mytype(unsigned long long n)
{
    return mytype{n};
}
// 부수 효과(side-effects)를 위한 용도
void operator""_print(const char* str)
{
    std::cout << str << '\n';
}
#if __cpp_nontype_template_args < 201911
std::string operator""_x2 (const char* str, std::size_t)
{
    return std::string{str} + str;
}
#else // C++20 문자열 리터럴 연산자 템플릿
template<std::size_t N>
struct DoubleString
{
    char p[N + N - 1]{};
    constexpr DoubleString(char const(&pp)[N])
    {
        std::ranges::copy(pp, p);
        std::ranges::copy(pp, p + N - 1);
    }
};
template<DoubleString A>
constexpr auto operator""_x2()
{
    return A.p;
}
#endif // C++20
int main()
{
    double x_rad = 90.0_deg_to_rad;
    std::cout << std::fixed << x_rad << '\n';
    mytype y = 123_mytype;
    std::cout << y.m << '\n';
    0x123ABC_print;
    std::cout << "abc"_x2 << '\n';
}

1.570796
123
0x123ABC
abcabc

표준 라이브러리

다음 리터럴 연산자들은 표준 라이브러리에 정의되어 있습니다:

결함 보고서

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