User-defined literals (since C++11)

Ermöglicht es Ganzzahl-, Gleitkomma-, Zeichen- und Zeichenkettenliteralen, Objekte benutzerdefinierten Typs zu erzeugen, indem ein benutzerdefinierter Suffix definiert wird.

Syntax

Ein benutzerdefinierter Literal ist ein Ausdruck einer der folgenden Formen

Wenn ein Token sowohl auf eine benutzerdefinierte Literalsyntax als auch auf eine reguläre Literalsyntax passt, wird angenommen, dass es sich um ein reguläres Literal handelt (das heißt, es ist unmöglich, LL in 123LL zu überladen).

Wenn der Compiler auf ein benutzerdefiniertes Literal mit dem ud-suffix X stößt, führt er einen unqualified name lookup durch, um nach einer Funktion mit dem Namen operator "" X zu suchen. Wenn die Suche keine Deklaration findet, ist das Programm fehlerhaft. Andernfalls,

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;    // ruft operator ""_w(1.2L) auf
    u"one"_w; // ruft operator ""_w(u"one", 3) auf
    12_w;     // ruft operator ""_w("12") auf
    "two"_w;  // Fehler: kein passender Literal-Operator
}

Wenn die Verkettung von Zeichenkettenliteralen in Übersetzungsphase 6 stattfindet, werden auch benutzerdefinierte Zeichenkettenliterale verkettet, und ihre ud-suffix e werden für die Verkettung ignoriert, mit der Ausnahme, dass nur ein Suffix auf allen verketteten Literalen erscheinen darf:

int main()
{
    L"A" "B" "C"_x;  // OK: gleiche Bedeutung wie L"ABC"_x
    "P"_x "Q" "R"_y; // Fehler: zwei verschiedene UD-Suffixe (_x und _y)
}

Literaloperatoren

Die von einem benutzerdefinierten Literal aufgerufene Funktion wird als literal operator bezeichnet (oder, falls es sich um ein Template handelt, literal operator template ). Sie wird wie jede andere Funktion oder function template im Namensbereich deklariert (sie kann auch eine Friend-Funktion, eine explizite Instanziierung oder Spezialisierung eines Funktions-Templates sein oder durch eine using-Deklaration eingeführt werden), mit Ausnahme der folgenden Einschränkungen:

Der Name dieser Funktion kann eine von zwei Formen haben:

ud-suffix muss mit dem Unterstrich _ beginnen: Die Suffixe, die nicht mit dem Unterstrich beginnen, sind für die von der Standardbibliothek bereitgestellten Literaloperatoren reserviert. Es darf ebenfalls keine doppelten Unterstriche __ enthalten: Solche Suffixe sind ebenfalls reserviert.

Wenn der Literaloperator eine Vorlage ist, muss er eine leere Parameterliste haben und kann nur einen Template-Parameter besitzen, der ein konstantes Template-Parameterpaket mit Elementtyp char sein muss (in diesem Fall wird er als numerischer Literaloperator-Template bezeichnet):

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

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

Nur die folgenden Parameterlisten sind für Literaloperatoren zulässig:

Standardargumente sind nicht erlaubt.

C language linkage ist nicht erlaubt.

Abgesehen von den oben genannten Einschränkungen sind Literaloperatoren und Literaloperatortemplates normale Funktionen (und Funktionsvorlagen). Sie können als inline oder constexpr deklariert werden, sie können internen oder externen Linkage haben, sie können explizit aufgerufen werden, ihre Adressen können genommen werden, usw.

#include <string>
void        operator ""_km(long double); // OK, wird für 1.0_km aufgerufen
void        operator "" _km(long double); // wie oben, veraltet
std::string operator ""_i18n(const char*, std::size_t); // OK
template<char...>
double operator ""_pi(); // OK
float  operator ""_e(const char*); // OK
// Fehler: Suffix muss mit Unterstrich beginnen
float operator ""Z(const char*);
// Fehler: alle Namen, die mit Unterstrich gefolgt von Großbuchstaben beginnen,
// sind reserviert (HINWEIS: ein Leerzeichen zwischen "" und _).
double operator"" _Z(long double);
// OK. HINWEIS: kein Leerzeichen zwischen "" und _.
double operator""_Z(long double);
// OK: Literaloperatoren können überladen werden
double operator ""_Z(const char* args);
int main() {}

Hinweise

Seit der Einführung benutzerdefinierter Literale ist Code, der Format-Makrokonstanten für Ganzzahltypen fester Breite ohne Leerzeichen nach dem vorangehenden Zeichenkettenliteral verwendet, ungültig geworden: std:: printf ( "%" PRId64 " \n " , INT64_MIN ) ; muss ersetzt werden durch std:: printf ( "%" PRId64 " \n " , INT64_MIN ) ; .

Aufgrund von maximal munch müssen benutzerdefinierte Ganzzahl- und Gleitkommaliterale, die auf p , P , (since C++17) e und E enden, wenn sie von den Operatoren + oder - gefolgt werden, im Quellcode durch Leerzeichen oder Klammern vom Operator getrennt werden:

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;   // Fehler
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;       // Fehler
auto u = 1_p +2;      // OK

Gleiches gilt für den Punktoperator nach einem ganzzahligen oder Gleitkomma-Benutzerdefinierten Literal:

#include <chrono>
using namespace std::literals;
auto a = 4s.count();   // Fehler
auto b = 4s .count();  // OK
auto c = (4s).count(); // OK

Andernfalls wird ein einzelner ungültiger Präprozessor-Zahlentoken (z.B., 1.0 _E + 2.0 oder 4s. count ) gebildet, was dazu führt, dass die Kompilierung fehlschlägt.

Schlüsselwörter

operator

Beispiele

#include <algorithm>
#include <cstddef>
#include <iostream>
#include <numbers>
#include <string>
// used as conversion from degrees (input param) to radians (returned output)
constexpr long double operator""_deg_to_rad(long double deg)
{
    long double radians = deg * std::numbers::pi_v<long double> / 180;
    return radians;
}
// used with custom type
struct mytype
{
    unsigned long long m;
};
constexpr mytype operator""_mytype(unsigned long long n)
{
    return mytype{n};
}
// used for 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 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

Standardbibliothek

Die folgenden Literaloperatoren sind in der Standardbibliothek definiert:

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.