C++ avanzado con biblioteca Boost

Las bibliotecas Boost están diseñadas para ser ampliamente útiles y utilizables en una amplia gama de aplicaciones. Por ejemplo, son útiles para manejar números grandes que tienen un rango más allá del tipo de datos long long, long double (2 ⁶⁴ ) en C++. 

Instalación

Consulte este artículo para la instalación de boost. Podemos descargar el archivo zip. Después de eso, solo necesitamos extraer todo en una carpeta específica de gcc o podemos hacerlo fácilmente mediante el símbolo del sistema.

Aplicaciones de ejemplo

Podemos usar esta biblioteca de manera eficiente en la programación competitiva , pero antes de eso, debemos asegurarnos de que su juez en línea sea compatible con boost. Aquí hay algunos trucos geniales que puedes usar:
 

1) Tipo de datos enteros grandes: podemos usar el tipo de datos int128_t, int256_t, int512_t o int1024_t según sus requisitos. Al usar estos, podemos lograr una precisión de hasta 1024 fácilmente. 

Debajo del código de implementación de C++ para encontrar el producto de números grandes:

// CPP Program to demonstrate Big Integer data type
#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
using namespace std;
 
int128_t boost_product(long long A, long long B)
{
    int128_t ans = (int128_t)A * B;
    return ans;
}
 
int main()
{
    long long first = 98745636214564698;
    long long second = 7459874565236544789;
    cout << "Product of " << first << " * " << second
         << " = \n"
         << boost_product(first, second);
    return 0;
}

Product of 98745636214564698 * 7459874565236544789 = 
736630060025131838840151335215258722

2) Tipo de datos de precisión arbitraria: podemos usar cualquier precisión con la ayuda del tipo de datos cpp_int si no estamos seguros de cuánta precisión se necesitará en el futuro. Convierte automáticamente la precisión deseada en el tiempo de ejecución. 

A continuación, la implementación del código C++ para encontrar el factorial de 30. 

// CPP Program to demonstrate Arbitrary precision data type
#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
using namespace std;
 
cpp_int boost_factorial(int num)
{
    cpp_int fact = 1;
    for (int i = num; i > 1; --i)
        fact *= i;
    return fact;
}
 
int main()
{
    int num = 30;
    cout << "Factorial of " << num << " = "
         << boost_factorial(num);
    return 0;
}

Producción: 

Factorial of 30 = 265252859812191058636308480000000

3) Multiprecision Float: Con Boost Multiprecision float, podemos lograr una precisión de hasta 50 y 100 decimales con cpp_float_50 y cpp_dec_float_100 respectivamente. 

A continuación se muestra el código de C++ para calcular el área de un círculo con diferente precisión mediante el uso de tipos float, decimal y cpp_float_50:

// CPP Program to demonstrate Boost Multiprecision float
#include <boost/math/constants/constants.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <iostream>
 
using boost::multiprecision::cpp_dec_float_50;
 
using namespace std;
 
template <typename T> inline T area_of_a_circle(T r)
{
    // pi represent predefined constant having value
    // 3.1415926535897932384...
    using boost::math::constants::pi;
    return pi<T>() * r * r;
}
 
int main()
{
    float radius_f = 123.0 / 100;
    float area_f = area_of_a_circle(radius_f);
 
    double radius_d = 123.0 / 100;
    double area_d = area_of_a_circle(radius_d);
 
    cpp_dec_float_50 r_mp = 123.0 / 100;
    cpp_dec_float_50 area_mp = area_of_a_circle(r_mp);
 
    // numeric_limits::digits10 represent the number
    // of decimal digits that can be held of particular
    // data type without any loss.
 
    // Area by using float data type
    cout << "Float: "
         << setprecision(numeric_limits<float>::digits10)
         << area_f << endl;
 
    // Area by using double data type
    cout << "Double: "
         << setprecision(numeric_limits<double>::digits10)
         << area_d << endl;
 
    // Area by using Boost Multiprecision
    cout << "Boost Multiprecision: "
         << setprecision(
                numeric_limits<cpp_dec_float_50>::digits10)
         << area_mp << endl;
    return 0;
}

Float: 4.75292
Double: 4.752915525616
Boost Multiprecision: 4.7529155256159980531876290929438093413108253981451

Este artículo es una contribución de Shubham Bansal. Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.