Note
	Функции, описанные в этом разделе, интенсивно используют функции языка C++11, в настоящее время (по состоянию на май 2013 года) только GCC-4.7 и более поздние, и Clang 3.3 и более поздние имеют поддержку, необходимую для работы этих функций.

Ограниченная поддержкаconstexprи определяемые пользователем буквы в библиотеке, в настоящее времячислопередняя часть поддерживаетconstexprна строительство по умолчанию и на всех экспедиторских конструкторах, но не на любом из операторов, не являющихся участниками. Так что если какой-то типBявляется буквальным типом, точисло<B>также является буквальным типом, и вы сможете компилировать-время-конструировать такой тип из любого литерала, из которогоBможно компилировать-время-конструируемый из. Тем не менее, вы не сможете выполнять арифметику времени компиляции на таких типах.

В настоящее время единственным типом бэкэнда, предоставляемым библиотекой, который также является буквальным типом, являются инстанциацииcpp_int_backend, где параметр Allocator является параметром типаvoid, а Проверенный параметр -boost::мультиточность::бесконтрольно.

Например:

using namespace boost::multiprecision;
constexpr int128_t            i = 0;     // OK, fixed precision int128_t has no allocator.
constexpr uint1024_t          j = 0xFFFFFFFF00000000uLL;  // OK, fixed precision uint1024_t has no allocator.
constexpr checked_uint128_t   k = -1; // Error, checked type is not a literal type as we need runtime error checking.
constexpr cpp_int             l = 2;  // Error, type is not a literal as it performs memory management.

Существует также ограниченная поддержка пользовательских определенных букв - они ограничены неконтролируемой, фиксированной точностьюcpp_int's, которые указаны в шестнадцатеричных обозначениях. Поддерживаемые суффиксы:

В каждом случае использование этих суффиксов с шестнадцатеричными значениями дает результатconstexpr.

Примеры:

//
// Any use of user defined literals requires that we import the literal-operators
// into current scope first:
using namespace boost::multiprecision::literals;
//
// To keep things simple in the example, we'll make our types used visible to this scope as well:
using namespace boost::multiprecision;
//
// The value zero as a number<cpp_int_backend<4,4,signed_magnitude,unchecked,void> >:
constexpr auto a = 0x0_cppi;
// The type of each constant has 4 bits per hexadecimal digit,
// so this is of type uint256_t (ie number<cpp_int_backend<256,256,unsigned_magnitude,unchecked,void> >):
constexpr auto b = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui;
//
// Smaller values can be assigned to larger values:
int256_t c = 0x1234_cppi; // OK
//
// However, this does not currently work in constexpr contexts:
constexpr int256_t d = 0x1_cppi; // Compiler error
//
// Constants can be padded out with leading zeros to generate wider types:
constexpr uint256_t e = 0x0000000000000000000000000000000000000000000FFFFFFFFFFFFFFFFFFFFF_cppui; // OK
//
// However, specific width types are best produced with specific-width suffixes,
// ones supported by default are `_cpp[u]i128`, `_cpp[u]i256`, `_cpp[u]i512`, `_cpp[u]i1024`.
//
constexpr int128_t f = 0x1234_cppi128; // OK, always produces an int128_t as the result.
constexpr uint1024_t g = 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbccccccccccccccccccccc_cppui1024;
//
// If other specific width types are required, then there is a macro for generating the operators
// for these.  The macro can be used at namespace scope only:
//
BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL(2048);
//
// Now we can create 2048-bit literals as well:
constexpr auto h = 0xff_cppi2048; // h is of type number<cpp_int_backend<2048,2048,signed_magnitude,unchecked,void> >
//
// Finally negative values are handled via the unary minus operator:
//
constexpr int1024_t i = -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF_cppui1024;
//
// Which means this also works:
constexpr int1024_t j = -g;   // OK: unary minus operator is constexpr.