Creando sus propias UDL en C ++ - dummies

La biblioteca estándar, junto con las funciones incorporadas de C ++, le proporciona una interesante variedad de literales. Sin embargo, el verdadero valor de los literales se vuelve más obvio cuando creas el tuyo propio.

Hay muchas necesidades diferentes que puede abordar usando Literales definidos por el usuario (UDL), pero tres necesidades comunes son la compatibilidad con las conversiones de datos, facilitando el trabajo de los tipos personalizados y la obtención de los efectos secundarios deseados sin la cantidad habitual de problemas de codificación.

Aunque los literales incorporados o de la Biblioteca estándar vienen en forma de prefijo y de sufijo, solo puede crear el formulario de sufijo al definir sus propios literales. Además, el sufijo debe comenzar con un guión bajo. El guión bajo sirve para ayudar a prevenir conflictos con los sufijos existentes y para asegurar que otros desarrolladores sepan que el literal es una forma personalizada (no estándar).

Desarrollando una conversión UDL

Es posible encapsular conversiones dentro de un UDL. Todo lo que necesita hacer una vez que crea dicha UDL es proporcionar el sufijo apropiado al definir la constante para obtener el resultado que desea. El ejemplo CustomUDL01 demuestra una técnica para definir una conversión que cambia la entrada del radio al área de un círculo en la constante.

#include using namespace std; constexpr double double operator "_circ (radio doble largo) {radio de retorno * radio * 3. 141592;} int main () {doble x = 5. 0_circ; cout <<" el área del círculo es: "<< x << endl; return 0;}

Para crear el UDL, el ejemplo se basa en un constexpr con un valor de retorno de un double largo y un valor de entrada, radio, de un double largo. La ecuación para calcular el área de un círculo es πr ² . Como puede ver, el ejemplo realiza el cálculo correcto como parte del constexpr.

Cuando crea un UDL personalizado, el compilador te obliga a usar el tipo más grande para la conversión. Lo que esto significa es que debes usar un doble largo para literales de coma flotante y unsigned long long para literales enteros. Incluso si luego eliges usar un tipo más pequeño, como se hace en este ejemplo al declarar x como un doble, el literal mismo debe emplear el tipo más grande posible.

Para declarar un UDL del nuevo tipo, el ejemplo crea x, que usa el sufijo _circ. s el resultado en pantalla. Cuando ejecuta este ejemplo, ve que el valor correcto se ha colocado en x, como se muestra aquí:

El área del círculo es: 78. 5398

Desarrollar un tipo de UDL personalizado

Gran parte del código que el encuentro depende de tipos personalizados que son difíciles de seguir y comprender.Crear un UDL para simplificar el código aclara las cosas y reduce el potencial de error. El ejemplo CustomUDL02 muestra un tipo personalizado, el operador utilizado para crear el UDL, así como también cómo se usa el UDL para definir un literal.

#include using namespace std; struct MyType {MyType (double Input): Value (Input) {} double Value;}; MyType operator "_mytype (double double Value) {return MyType (Value);} int main () {auto UDLType = 145. 6_mytype; cout << uDLType. Value << endl; return 0;}

Para que esto ocurra Para trabajar, debe crear un constructor para su tipo que acepte la cantidad de entradas necesarias para configurar el tipo. Como mínimo, el constructor debe aceptar un tipo o el valor de entrada que el usuario proporciona se pierde.

El tipo personalizado necesita no es compatible con el mismo tipo de datos de tamaño que requiere el operador, pero deben ser del mismo tipo. Por ejemplo, no puede hacer la transición de un doble largo a un int.

Cuando ejecuta este ejemplo, ve una salida valor de 145. 6, que es el valor que ingresa al tipo personalizado. Es posible manejar configuraciones bastante complejas con este enfoque. El usuario de su tipo personalizado obtiene la capacidad de crear código claro que es fácil de seguir e interpretar, incluso cuando los tipos subyacentes son complejos.

Usando un UDL personalizado para efectos secundarios

Uno de los más interesantes ses para UDLs es crear efectos secundarios (una operación que no es la normal ni la normal, ya sea para hacer que la aplicación sea más corta y más eficiente o para proporcionar mayor flexibilidad). Desea definir un cierto tipo de operación que tiene lugar como resultado de la definición del literal.

Lo que obtienes sigue siendo un literal, pero un literal que no necesariamente denota un valor que planeas usar más adelante. El ejemplo CustomUDL03 muestra uno de esos usos no tradicionales.

#include using namespace std; void operator "_countdown (valor largo sin signo) {for (int i = Value; i> = 0; i--) cout << i << endl;} int main () {10_countdown; return 0;}

Observe que el operador _countdown no está conectado a algo que normalmente asociaría con un valor. De hecho, no devuelve ningún valor. Lo que obtiene en su lugar es un efecto secundario. Cuando ejecuta este ejemplo, vea esta salida.

10 9 8 7 6 5 4 3 2 1 0

Lo que sucedió es que el compilador reemplazó 10_countdown con sentencias cout individuales, una para cada iteración del ciclo. Lo que termina es 11 instrucciones cout que generan los valores entre 10 y 0 (en orden inverso). El efecto secundario UDL abre todo tipo de posibilidades interesantes para crear código que simplifica ciertas tareas repetitivas de una manera que hace obvio su uso.