User-defined literals (since C++11)

Позволяет целочисленным, вещественным, символьным и строковым литералам создавать объекты пользовательского типа путем определения пользовательского суффикса.

Синтаксис

Пользовательский литерал — это выражение одного из следующих видов

Если токен соответствует синтаксису пользовательского литерала и синтаксису обычного литерала, считается, что это обычный литерал (то есть невозможно перегрузить LL в 123LL ).

Когда компилятор встречает пользовательский литерал с ud-суффиксом 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-суффиксы игнорируются для целей конкатенации, за исключением того, что только один суффикс может присутствовать на всех объединённых литералах:

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 в области видимости пространства имён (она также может быть функцией-другом, явным инстанцированием или специализацией шаблона функции, или введена через using-декларацию), за исключением следующих ограничений:

Название этой функции может иметь одну из двух форм:

ud-суффикс должен начинаться с подчеркивания _ : суффиксы, которые не начинаются с подчеркивания, зарезервированы для литеральных операторов, предоставляемых стандартной библиотекой. Он также не может содержать двойных подчеркиваний __ : такие суффиксы также зарезервированы.

Если литеральный оператор является шаблоном, он должен иметь пустой список параметров и может иметь только один шаблонный параметр, который должен быть константным шаблонным параметром-пакетом с типом элементов 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 ) ; .

Из-за максимального поглощения , пользовательские целочисленные и литералы с плавающей точкой, оканчивающиеся на p , P , (since 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;   // OK
auto z = 1.0_E +2.0;  // OK
auto q = (1.0_E)+2.0; // OK
auto w = 1_p+2;       // ошибка
auto u = 1_p +2;      // OK

То же самое относится к оператору точки, следующему за целочисленным или плавающим пользовательским литералом:

#include <chrono>
using namespace std::literals;
auto a = 4s.count();   // Ошибка
auto b = 4s .count();  // OK
auto c = (4s).count(); // OK

В противном случае формируется единственный некорректный токен препроцессорного числа (например, 1.0 _E + 2.0 или 4s. count ), что приводит к ошибке компиляции.

Ключевые слова

operator

Примеры

#include <algorithm>
#include <cstddef>
#include <iostream>
#include <numbers>
#include <string>
// используется для преобразования градусов (входной параметр) в радианы (возвращаемое значение)
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};
}
// используется для побочных эффектов
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 string literal operator template
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++.