[over.literal]

The user-defined-string-literal in a literal-operator-id shall have no encoding-prefix.

The unevaluated-string or user-defined-string-literal shall be empty.

The ud-suffix of the user-defined-string-literal or the identifier in a literal-operator-id is called a literal suffix identifier.

The first form of literal-operator-id is deprecated ([depr.lit]).

Some literal suffix identifiers are reserved for future standardization; see [usrlit.suffix].

A declaration whose literal-operator-id uses such a literal suffix identifier is ill-formed, no diagnostic required.

A declaration whose declarator-id is a literal-operator-id shall declare a function or function template that belongs to a namespace (it could be a friend function ([class.friend])) or an explicit instantiation or specialization of a function template.

A function declared with a literal-operator-id is a literal operator.

A function template declared with a literal-operator-id is a literal operator template.

The declaration of a literal operator shall have a parameter-declaration-clause equivalent to one of the following: const char* unsigned long int long double char wchar_t char8_t char16_t char32_t const char*, std::size_t const wchar_t*, std::size_t const char8_t*, std::size_t const char16_t*, std::size_t const char32_t*, std::size_t

If a parameter has a default argument ([dcl.fct.default]), the program is ill-formed.

A raw literal operator is a literal operator with a single parameter whose type is const char*.

A numeric literal operator template is a literal operator template whose template-parameter-list has a single template-parameter that is a constant template parameter pack ([temp.variadic]) with element type char.

A string literal operator template is a literal operator template whose template-parameter-list comprises a single parameter-declaration that declares a constant template parameter of class type.

The declaration of a literal operator template shall have an empty parameter-declaration-clause and shall declare either a numeric literal operator template or a string literal operator template.

[Note 1:

Literal operators and literal operator templates are usually invoked implicitly through user-defined literals ([lex.ext]).

However, except for the constraints described above, they are ordinary namespace-scope functions and function templates.

In particular, they are looked up like ordinary functions and function templates and they follow the same overload resolution rules.

Also, they can be declared inline or constexpr, they can have internal, module, or external linkage, they can be called explicitly, their addresses can be taken, etc.

— end note]

[Example 1: void operator ""_km(long double); / OK string operator "" _i18n(const char*, std::size_t); / OK, deprecated template <char.> double operator ""_\u03C0(); / OK, UCN for lowercase pi float operator ""_e(const char*); / OK float operator ""E(const char*); / ill-formed, no diagnostic required: / reserved literal suffix ([usrlit.suffix], [lex.ext]) double operator""_Bq(long double); / OK, does not use the reserved identifier _Bq ([lex.name]) double operator"" _Bq(long double); / ill-formed, no diagnostic required: / uses the reserved identifier _Bq ([lex.name]) float operator " "B(const char*); / error: non-empty string-literal string operator ""5X(const char*, std::size_t); / error: invalid literal suffix identifier double operator ""_miles(double); / error: invalid parameter-declaration-clause template <char.> int operator ""_j(const char*); / error: invalid parameter-declaration-clause extern "C" void operator ""_m(long double); / error: C language linkage — end example]

12 Overloading [over]

12.6 User-defined literals [over.literal]