Using the GNU MPFR library in C++

#include <iostream>
#include <cstdlib>
#include <cstdint>
#include <cstdio>
#include <stdarg.h>
#include <mpfr.h>

class MP
{
public:
    MP(mpfr_prec_t precision = 4096)
    {
        mpfr_init2(m_value, precision);
    };

    virtual ~MP()
    {
        mpfr_clear(m_value);
    }

    MP& operator=(const double val)
    {
        mpfr_set_d(m_value, val, MPFR_RNDN);
        return *this;
    }

    MP& operator=(const MP &valstr)
    {        
        mpfr_set(m_value, valstr.m_value, MPFR_RNDN);
        return *this;
    }

    MP& operator=(const std::string &valstr)
    {
        mpfr_set_str(m_value, valstr.c_str(), 10, MPFR_RNDN);
        return *this;
    }

    MP operator+(const MP &other)
    {
        MP result(m_value->_mpfr_prec);

        mpfr_add(result.m_value, m_value, other.m_value, MPFR_RNDN);
        return result;
    }

    MP& operator+=(const MP &other)
    {
        mpfr_add(m_value, m_value, other.m_value, MPFR_RNDN);
        return *this;
    }

    MP operator-(const MP &other) const
    {
        MP result(m_value->_mpfr_prec);

        mpfr_sub(result.m_value, m_value, other.m_value, MPFR_RNDN);
        return result;
    }

    MP& operator-=(const MP &other)
    {
        mpfr_sub(m_value, m_value, other.m_value, MPFR_RNDN);
        return *this;
    }

    MP operator*(const MP &other) const
    {
        MP result(m_value->_mpfr_prec);

        mpfr_mul(result.m_value, m_value, other.m_value, MPFR_RNDN);
        return result;
    }

    MP operator/(const MP &other) const
    {
        MP result(m_value->_mpfr_prec);

        mpfr_div(result.m_value, m_value, other.m_value, MPFR_RNDN);
        return result;
    }

    bool operator>(const MP &other) const
    {
        return mpfr_cmp(m_value, other.m_value) > 0;
    }

    bool operator<(const MP &other) const
    {
        return mpfr_cmp(m_value, other.m_value) < 0;
    }

    const mpfr_t& get() const noexcept
    {
        return m_value;
    }

    friend MP abs(const MP &v);

protected:
    mpfr_t m_value;
};

MP abs(const MP &v)
{
    MP result(v.m_value->_mpfr_prec);
    mpfr_abs(result.m_value, v.m_value, MPFR_RNDN);
    return result;
}

std::ostream& operator<<(std::ostream &os, const MP &value)
{
    char *buffer;
    mpfr_asprintf(&buffer, "%RE", value.get());
    os << buffer;
    mpfr_free_str(buffer);
    return os;
}

int main(int argc, char *argv[])
{
    MP half(128);
    MP x(128);
    MP y(128);
    MP eps(128);

    eps  = 1.0e-37; // max error
    half = 0.5;     // constant
    y = 2.0;        // determine sqrt of this value
    x = 1.0;        // starting guess

    // Newton iterations, with error limit.
    MP error(128);
    error = abs(x*x - y);
    while(error > eps)
    {
        x = half*(x + y/x);
        error = abs(x*x - y);

        std::cout << "  x=" << x << "  err=" << error << "\n";
    }

    return EXIT_SUCCESS;
}