C++ / constexpr

Bienvenidos sean a este post, hoy veremos un especificador.

Este declara que el valor de la funcion es posible a evaluarlo en tiempo de compilacion, esto tambien aplica a las variables. Su nombre consiste de const y expresion. Su principal caracteristica es la capacidad de optimizar nuestro codigo al maximo. Vamos a analizar el siguiente ejemplo:

#define NUMERO 42
#include <iostream>

int doble(int n)
{
        return n * 2;
}

constexpr int triple(int n)
{
        return n * 3;
}

int main()
{
        int doblado = doble(NUMERO);
        int triplado = triple(NUMERO);
        int prueba{1};
        int otro_triple = triple(prueba);

        std::cout << doblado << std::endl;
        std::cout << triplado << std::endl;
        std::cout << otro_triple << std::endl;

        return 0;
}

A parte de aplicar el tema de este post, aplicamos uno ya comentado y otro nuevo. Primero usamos un preprocessor para establecer un valor que podemos usar como constante, no es lo correcto pero para fines practicos lo usaremos asi. Despues tenemos dos funciones, las cuales reciben un valor y en una devolveremos la multiplicacion de este por dos y la otra por tres. La unica diferencia es que en la segunda funcion aplicamos a constexpr. Ya veremos como afecta esto. En el main, definiremos cuatro variables. La primeras dos seran del mismo tipo que las funciones y en ambos casos le asignaremos el resultado de las funciones anteriores. En ambos casos, le pasamos el valor que definimos al inicio. La siguiente variable sera iniciada con el valor que le pasamos entre las llaves. Este es un metodo para usarlo en lugar del operador de asignacion. Y la ultima sera contenedora de otro llamado a la funcion triple pero ahora le pasamos la variable anterior. Antes de ver la salida, veamos como ve el codigo el compilador:

#define NUMERO 42
#include <iostream>

int doble(int n)
{
        return n * 2;
}

constexpr int triple(int n)
{
        return n * 3;
}

int main()
{
        int doblado = doble(42);
        int triplado = 126;
        int prueba = 1;
        int otro_triple = 3;

        std::cout << doblado << std::endl;
        std::cout << triplado << std::endl;
        std::cout << otro_triple << std::endl;

        return 0;
}

En el caso de doble le asigna el valor de la «constante» pero en los tres casos, resuelve la operacion y le asigna el valor para manipularlo directamente. Si lo compilan y ejecutan el unico valor faltante es el doble de NUMERO, el resto son los valores que ven. Tomemos este codigo y en el main hagamos la siguiente modificacion:

int main()
{
        int doblado = doble(NUMERO);
        int triplado = triple(NUMERO);
        int prueba{0};
        std::cout << "Ingresa un valor: ";
        std::cin >> prueba;
        int otro_triple = triple(prueba);

        std::cout << doblado << std::endl;
        std::cout << triplado << std::endl;
        std::cout << otro_triple << std::endl;

        return 0;
}

En este caso, primero le damos un nuevo valor inicial a prueba. Lo siguiente es la accion de pedir que ingresemos un valor y este lo asignaremos a la variable anterior. El resto sigue de la misma manera. Pero cual es la diferencia mas alla de nuestra modificacion en el ingreso? Bueno, veamos como ve ahora al codigo nuestro compilador:

int main()
{
        int doblado = doble(42);
        int triplado = 126;
        int prueba = 0;
        std::cout << "Ingresa un valor: ";
        std::cin >> prueba;
        int otro_triple = triple(prueba);

        std::cout << doblado << std::endl;
        std::cout << triplado << std::endl;
        std::cout << otro_triple << std::endl;

        return 0;
}

Sigue estableciendo los valores como vimos anteriormente pero la diferencia ahora esta en la ultima variable. En esta no resuelve el valor sino que sigue utilizando a la funcion con la variable que posee el valor. Esto es asi porque al no tener un valor asignado no tiene forma de procesarlo hasta que lo ingresemos. Esta es una mejor manera de pre-procesar los valores con respecto a los heredados de C. Y si bien, no son una garantia absoluta tienen una mayor efectividad a la hora de trabajar. Igualmente, tengan en cuenta que estan son caracteristicas que se agregaron en C++20 y en versiones anteriores no existen por lo tanto, deben usar los metodos heredados de C.

En resumen, hoy hemos visto a constexpr, que es, para que sirve, como se utiliza, un ejemplo para verlo en accion, y algunos temas a tener en cuenta. Espero les haya resultado de utilidad sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.