Ejemplo de literales definidos por el usuario de C ++

Permite que los literales enteros, de coma flotante, de caracteres y de cadena produzcan objetos de tipo definido por el usuario mediante la definición de un sufijo definido por el usuario.

Sintaxis

Un literal definido por el usuario es una expresión de cualquiera de las siguientes formas.

1-4) literales enteros definidos por el usuario, como 12_km5-6) literales de punto flotante definidos por el usuario, como 0.5_Pa7) literal de carácter definido por el usuario, como 'c'_X8) literal de cadena definida por el usuario, como "abd"_L o u"xyz"_M

Si un token coincide con una sintaxis literal definida por el usuario y una sintaxis literal regular, se supone que es un literal regular (es decir, es imposible sobrecargar LL en 123LL).

Cuando el compilador encuentra un literal definido por el usuario con sufijo udX, realiza una búsqueda de nombre no calificado, buscando una función con el nombre operator "" X. Si la búsqueda no encuentra una declaración, el programa está mal formado. De lo contrario,

1) Para literales enteros definidos por el usuarioa) si el conjunto de sobrecarga incluye un operador literal con el tipo de parámetro unsigned long long, la expresión literal definida por el usuario se trata como una llamada de función operator "" X(nULL), donde n es el literal sin sufijo udB) de lo contrario, el conjunto de sobrecarga debe incluir, pero no ambos, un operador literal sin formato o una plantilla de operador literal numérico. Si el conjunto de sobrecarga incluye un operador literal sin formato, la expresión literal definida por el usuario se trata como una llamada de función. operator "" X("n")C) de lo contrario, si el conjunto de sobrecarga incluye una plantilla de operador literal numérico, la expresión literal definida por el usuario se trata como una llamada de función operator "" X<'c1', 'c2', 'c3'..., 'ck'>(), donde c1..ck son los caracteres individuales de n.2) Para literales de punto flotante definidos por el usuario,a) Si el conjunto de sobrecarga incluye un operador literal con el tipo de parámetro long double, la expresión literal definida por el usuario se trata como una llamada a función operator "" X(fL), dónde f es el literal sin sufijo udB) de lo contrario, el conjunto de sobrecarga debe incluir, pero no ambos, un operador literal sin formato o una plantilla de operador literal numérico. Si el conjunto de sobrecarga incluye un operador literal sin formato, la expresión literal definida por el usuario se trata como una llamada de función. operator "" X("f")C) de lo contrario, si el conjunto de sobrecarga incluye una plantilla de operador literal numérico, la expresión literal definida por el usuario se trata como una llamada de función operator "" X<'c1', 'c2', 'c3'..., 'ck'>(), donde c1..ck son los caracteres individuales de f.3) Para literales de cadena definidos por el usuario, deje str ser el literal sin sufijo ud:

B) de lo contrario, la expresión literal definida por el usuario se trata como una llamada de función operator "" X (str, len), dónde len es la longitud de la cadena literal, excluyendo el carácter nulo de terminación4) Para los literales de caracteres definidos por el usuario, la expresión literal definida por el usuario se trata como una llamada de función. operator "" X(ch), dónde ch es el literal sin sufijo ud

longdoubleoperator""_w(longdouble);
std::string operator""_w(constchar16_t*, size_t);unsignedoperator""_w(constchar*);intmain()1.2_w;// calls operator "" _w(1.2L)
    u"one"_w;// calls operator "" _w(u"one", 3)12_w;// calls operator "" _w("12")"two"_w;// error: no applicable literal operator

Cuando la concatenación literal de cadena tiene lugar en la fase de traducción 6, las cadenas literales definidas por el usuario también se concatenan, y su sufijo udes se ignoran con el propósito de la concatenación, excepto que solo puede aparecer un sufijo en todos los literales concatenados:

intmain()
    L"A""B""C"_x;// OK: same as L"ABC"_x"P"_x "Q""R"_y;// error: two different ud-suffixes (_x and _y)

Operadores literales

La función llamada por un literal definido por el usuario se conoce como operador literal (o, si es una plantilla, plantilla de operador literal). Se declara como cualquier otra función o plantilla de función en el ámbito del espacio de nombres (también puede ser una función amiga, una instanciación explícita o especialización de una plantilla de función, o introducida por una declaración de uso), excepto por las siguientes restricciones:

El nombre de esta función puede tener una de estas dos formas:

Si el operador literal es una plantilla, debe tener una lista de parámetros vacía y solo puede tener un parámetro de plantilla, que debe ser un paquete de parámetros de plantilla sin tipo con tipo de elemento char (en cuyo caso se conoce como plantilla de operador literal numérico).

template<char...>doubleoperator""_x();

structAA(constchar*);autooperator<=>(const A&)const=default;;template<A a> A operator""_a();

Solo se permiten las siguientes listas de parámetros en operadores literales:

1) Los operadores literales con esta lista de parámetros son los operadores literales sin formato, utilizado como reserva para literales definidos por el usuario de punto flotante y entero (ver más arriba)2) Los operadores literales con estas listas de parámetros son el operador literal de primera elección para literales enteros definidos por el usuario3) Los operadores literales con estas listas de parámetros son el operador literal de primera elección para literales de punto flotante definidos por el usuario4-8) Los operadores literales con estas listas de parámetros son llamados por literales de caracteres definidos por el usuario9-13) Los operadores literales con estas listas de parámetros son llamados por literales de cadena definidos por el usuario

No se permiten argumentos predeterminados.

No se permite la vinculación del lenguaje C.

Aparte de las restricciones anteriores, los operadores literales y las plantillas de operadores literales son funciones normales (y plantillas de funciones), se pueden declarar en línea o constexpr, pueden tener enlaces internos o externos, se pueden llamar explícitamente, se pueden tomar sus direcciones, etc. .

voidoperator""_km(longdouble);// OK, will be called for 1.0_km
std::string operator""_i18n(constchar*, std::size_t);// OKtemplate<char...>doubleoperator"" _π();// OKfloatoperator""_e(constchar*);// OKfloatoperator""Z(constchar*);// error: suffix must begin with underscoredoubleoperator""_Z(longdouble);// error: all names that begin with underscore// followed by uppercase letter are reserveddoubleoperator""_Z(longdouble);// OK: even though _Z is reserved ""_Z is allowed

Notas

Desde la introducción de literales definidos por el usuario, el código que usa Formatear constantes de macro para tipos enteros de ancho fijo sin espacio después de que el literal de cadena anterior dejara de ser válido: std::printf("%"PRId64"n",INT64_MIN); tiene que ser reemplazado por std::printf("%"PRId64"n",INT64_MIN);

Debido al munch máximo, enteros definidos por el usuario y literales de punto flotante que terminan en p, P,(desde C ++ 17)e y E, cuando es seguido por los operadores + o -, debe estar separado del operador con espacios en blanco o paréntesis en la fuente:

longdoubleoperator""_E(longdouble);longdoubleoperator""_a(longdouble);intoperator""_p(unsignedlonglong);auto x =1.0_E+2.0;// errorauto y =1.0_a+2.0;// OKauto z =1.0_E +2.0;// OKauto q =(1.0_E)+2.0;// OKauto w =1_p+2;// errorauto u =1_p +2;// OK

Lo mismo se aplica al operador de punto que sigue a un literal definido por el usuario entero o de punto flotante:

#includeusingnamespace std::literals;auto a =4s.count();// Errorauto b =4s .count();// OKauto c =(4s).count();// OK

De lo contrario, un solo token de número de preprocesamiento no válido (p. Ej., 1.0_E+2.0 o 4s.count) se forma, lo que hace que falle la compilación.

Ejemplos de

#include// used as conversionconstexprlongdoubleoperator""_deg(longdouble deg )return deg *3.14159265358979323846264L/180;// used with custom typestructmytypeunsignedlonglong m;;constexpr mytype operator""_mytype(unsignedlonglong n )return mytypen;// used for side-effectsvoidoperator""_print(constchar* str )
    std::cout << str;intmain()double x =90.0_deg;
    std::cout << std::fixed << x <<'n';
    mytype y =123_mytype;
    std::cout << y.m <<'n';0x123ABC_print;

Producción:

1.5707961230x123ABC

Biblioteca estándar

Los siguientes operadores literales se definen en la biblioteca estándar.