biggest integer datatype in c++?

Question

Which is the biggest integer datatype in c++?

Answer 1

The biggest standard C++ integer type is long.

C has a long long, and C++0x is going to add that as well, and of course you could implement your own custom integer type, perhaps even a BigInt class.

But technically speaking, considering the built-in integer types, long is your answer.

Answer 2

The long long data-type is the largest built-in integral datatypes in standard C99 and C++0x. Just as with all of the other integral data types, long long is not given an exact size in bytes. Instead, it is defined to be at least a 64-bit integer. While long long is not part of the official C++ standard, it is ubiquitously supported across modern compilers. Note, however, that many compilers for modern desktops define long and long long as both exactly 64-bits, whereas many compilers for embedded processors define long as 32-bits and long long as 64-bits (obviously witha few exceptions).

If you need more precision or absolutely cannot use the long long language extension, you're going to have to use one of the C or C++ libraries that are designed to work with extremely large or small numbers.

Answer 3

You might prefer to avoid worrying about primitive names by mapping to the largest (fully realised) type on the compiling architecture via <cstdint> and its typedefs intmax_t and uintmax_t.

I was surprised no one else said this, but cursory research indicates it was added in C++11, which can probably explain the lack of previous mentions. (Although its fellow new primitive/built-in type long long was cited!)

Some compilers may also provide larger types, though these may come with caveats, for instance: Why in g++ std::intmax_t is not a __int128_t?

Personally, I'm using cstdint as it's easier to quickly see how many bytes minimum I'm using - rather than having to remember how many bits a given primitive corresponds to - and the standard means it avoids my types being platform-dependent. Plus, for what I do, uint8_t is faster and neater than endless unsigned chars!

edit: In hindsight, I want to clarify: uint8_t is not guaranteed to be equivalent to unsigned char. Sure, it is on my machines, and it probably is for you, too. But this equivalance is not required by the Standard; see: When is uint8_t ≠ unsigned char? For that reason, now when I need the Standard-defined special abilities of [[un]signed] char, I use only that.

Answer 4

There are 128 bit packed integer and floating point formats defined in xmmintrin.h on compilers that support SSE to enable use of the SSE registers and instructions. They are not part of the C++ standard of course, but since they are supported by MSVC, GCC and the Intel C++ Compiler there is a degree of cross-platform support (at least OS X, Linux and Windows for Intel CPUs). Other ISAs have SIMD extensions so there are probably other platform/compiler specific extensions that support 128 or 256 bit SIMD instructions. Intel's upcoming AVX instruction set will have 256 bit registers, so we should see a new set of data types and intrinsics for that.

They don't behave quite like built-in data types (i.e., you have to use intrinsic functions instead of operators to manipulate them, and they work with SIMD operations) but since they do in fact map to 128-bit registers on the hardware they deserve mention.

Details about Streaming SIMD Extension (SSE)Intrinsics

Answer 5

boost::multiprecision::cpp_int is an arbitrary precision integer type. So there is no "biggest integer datatype" in C++. Just a biggest builtin integral type, which AFAIK is long in standard C++.

Answer 6

You can easily get bigger datatype by defining your own Class. You can get inspired from the class BigInteger in Java. It's a nice one but it's not necessarily an actual integer even if it acts exactly like one.

Answer 7

In the Borland and Microsoft compilers, __int64 is probably the largest you can get.

Answer 8

The __int128_t and __uint128_t (unsigned __int128_t) data types are 128 bits long, double the size of a long long (which is 64 bits long for those new to c++). However, if you are going to use them, then you need to do some overloading because the int128 data type is not too deeply supported (in Mingw, at least). This is an example of how you can use it to show 2^x-1 up until 2^128-1

#include <iostream>

char base10_lookup_table[10]={'0','1','2','3','4','5','6','7','8','9'};

std::ostream&
operator<<( std::ostream& dest, __int128 value )
{
    std::ostream::sentry s( dest );
    if ( s ) {
        __uint128_t tmp = value < 0 ? -value : value;
        char buffer[ 128 ];
        char* d = std::end( buffer );
        do
        {
            -- d;
            *d = base10_lookup_table[ tmp % 10 ];
            tmp /= 10;
        } while ( tmp != 0 );
        if ( value < 0 ) {
            -- d;
            *d = '-';
        }
        int len = std::end( buffer ) - d;
        if ( dest.rdbuf()->sputn( d, len ) != len ) {
            dest.setstate( std::ios_base::badbit );
        }
    }
    return dest;
}

std::ostream&
operator<<( std::ostream& dest, unsigned __int128 value )
{
    std::ostream::sentry s( dest );
    if ( s ) {
        __uint128_t tmp = value < 0 ? -value : value;
        char buffer[ 128 ];
        char* d = std::end( buffer );
        do
        {
            -- d;
            *d = base10_lookup_table[ tmp % 10 ];
            tmp /= 10;
        } while ( tmp != 0 );
        if ( value < 0 ) {
            -- d;
            *d = '-';
        }
        int len = std::end( buffer ) - d;
        if ( dest.rdbuf()->sputn( d, len ) != len ) {
            dest.setstate( std::ios_base::badbit );
        }
    }
    return dest;
}



int main ( void )
{
    __uint128_t big_value = 0;      //unsigned int128

    for ( unsigned char i=0; i!=129; ++i )   //I am using an unsigned char because it can hold all the values that will be used
    {
        std::cout << "1 less than 2 to the power of " << int(i) << " = \0" << big_value << "\n";
        big_value |= (__uint128_t)1 << i;
    }

    return 0;    //formal way of exiting
}

The problem with the int128 datatype is that not all compilers may support it.

Answer 9

Repl.it says that unsigned long long int is actually a valid type, and I find that very interesting.