# Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world.

##### Construction from Specific Values Without Precision Loss

Construction of multiprecision types from built-in floating-point types can lead to potentially unexpected, yet correct, results. Consider, for instance constructing an instance of `cpp_dec_float_50` from the literal built-in floating-point `double` value 11.1.

```#include <iomanip>
#include <iostream>
#include <limits>

#include <boost/multiprecision/cpp_dec_float.hpp>

int main()
{
using my_dec_100 = boost::multiprecision::cpp_dec_float_50;

const my_dec_100 f11(11.1);

// On a system with 64-bit double:
// 11.09999999999999964472863211994990706443786621093750
std::cout << std::setprecision(std::numeric_limits<my_dec_100>::digits10)
<< std::fixed
<< f11
<< std::endl;
}
```

In this example, the system has a 64-bit built in `double` representation. The variable `f11` is initialized with the literal `double` value 11.1. Recall that built-in floating-point representations are based on successive binary fractional approximations. These are, in fact, very close approximations. But they are approximations nonetheless, having their built-in finite precision.

For this reason, the full multiple precision value of the `double` approximation of 11.1 is given by the large value shown above. Observations show us that the value is reliable up to the approximate 15 decimal digit precision of built-in 64-bit `double` on this system.

If the exact value of 11.1 is desired (within the wider precision of the multiprecision type), then construction from literal string or from a rational integral construction/division sequence should be used.

```const my_dec_100 f11_str("11.1");
const my_dec_100 f11_n  (my_dec_100(111) / 10);
```