整数类型可以在 C + + 中存储多大范围的值？

You should look at the specialisations of the numeric_limits<> template for a given type. It’s in the <limits> header.

The size of the numerical types is not defined in the C++ standard, although the minimum sizes are. The way to tell what size they are on your platform is to use numeric limits

For example, the maximum value for a int can be found by:

std::numeric_limits<int>::max();

Computers don't work in base 10, which means that the maximum value will be in the form of 2ⁿ-1 because of how the numbers of represent in memory. Take for example eight bits (1 byte)

  0100 1000

The right most bit (number) when set to 1 represents 2⁰, the next bit 2¹, then 2² and so on until we get to the left most bit which if the number is unsigned represents 2⁷.

So the number represents 2⁶ + 2³ = 64 + 8 = 72, because the 4th bit from the right and the 7th bit right the left are set.

If we set all values to 1:

11111111

The number is now (assuming unsigned)
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2⁸ - 1
And as we can see, that is the largest possible value that can be represented with 8 bits.

On my machine and int and a long are the same, each able to hold between -2³¹ to 2³¹ - 1. In my experience the most common size on modern 32 bit desktop machine.

Can unsigned long int hold a ten digits number (1,000,000,000 - 9,999,999,999) on a 32-bit computer.

No

No, only part of ten digits number can be stored in a unsigned long int whose valid range is 0 to 4,294,967,295.

You can refer to this: http://msdn.microsoft.com/en-us/library/s3f49ktz(VS.80).aspx

The minimum ranges you can rely on are:

• short int and int: -32,767 to 32,767
• unsigned short int and unsigned int: 0 to 65,535
• long int: -2,147,483,647 to 2,147,483,647
• unsigned long int: 0 to 4,294,967,295

This means that no, long int cannot be relied upon to store any 10-digit number. However, a larger type, long long int, was introduced to C in C99 and C++ in C++11 (this type is also often supported as an extension by compilers built for older standards that did not include it). The minimum range for this type, if your compiler supports it, is:

• long long int: -9,223,372,036,854,775,807 to 9,223,372,036,854,775,807
• unsigned long long int: 0 to 18,446,744,073,709,551,615

So that type will be big enough (again, if you have it available).

A note for those who believe I've made a mistake with these lower bounds: the C requirements for the ranges are written to allow for ones' complement or sign-magnitude integer representations, where the lowest representable value and the highest representable value differ only in sign. It is also allowed to have a two's complement representation where the value with sign bit 1 and all value bits 0 is a trap representation rather than a legal value. In other words, int is not required to be able to represent the value -32,768.

Other folks here will post links to data_sizes and precisions, etc. I'm going to tell you how to figure it out yourself. Write a small application that will do the following.

unsigned int ui;
std::cout << sizeof(ui));

This will (depending on compiler and architecture) print 2, 4 or 8, saying 2 bytes long, 4 bytes long, etc.

Let’s assume it's 4.

You now want the maximum value 4 bytes can store, the maximum value for one byte is (in hexadecimal) 0xFF. The maximum value of four bytes is 0x followed by 8 f's (one pair of f's for each byte, and the 0x tells the compiler that the following string is a hex number). Now change your program to assign that value and print the result:

unsigned int ui = 0xFFFFFFFF;
std::cout << ui;

that’s the maximum value an unsigned int can hold, shown in base 10 representation.

Now do that for long's, shorts and any other INTEGER value you're curious about.

NB: This approach will not work for floating point numbers (i.e. double or float).

For an unsigned data type, there isn't any sign bit and all bits are for data ; whereas for a signed data type, MSB is indicating a sign bit and the remaining bits are for data.

To find the range, do the following things:

Step 1: Find out number of bytes for the given data type.

Step 2: Apply the following calculations.

      Let n = number of bits in data type


For signed data type ::
Lower Range = -(2^(n-1))
Upper Range = (2^(n-1)) - 1)


For unsigned data type ::
Lower Range = 0
Upper Range = (2^(n)) - 1

For example,

For unsigned int size = 4 bytes (32 bits) → Range [0, (2^(32)) - 1]

For signed int size = 4 bytes (32 bits) → Range [-(2^(32-1)), (2^(32-1)) - 1]

To find out the limits on your system:

#include <iostream>
#include <limits>
int main(int, char **) {
std::cout
<< static_cast< int >(std::numeric_limits< char >::max()) << "\n"
<< static_cast< int >(std::numeric_limits< unsigned char >::max()) << "\n"
<< std::numeric_limits< short >::max() << "\n"
<< std::numeric_limits< unsigned short >::max() << "\n"
<< std::numeric_limits< int >::max() << "\n"
<< std::numeric_limits< unsigned int >::max() << "\n"
<< std::numeric_limits< long >::max() << "\n"
<< std::numeric_limits< unsigned long >::max() << "\n"
<< std::numeric_limits< long long >::max() << "\n"
<< std::numeric_limits< unsigned long long >::max() << "\n";
}

Note that long long is only legal in C99 and in C++11.

In C++, now int and other data is stored using the two's complement method.

That means the range is:

-2147483648 to 2147483647

or -2^31 to 2^31-1.

1 bit is reserved for 0 so positive value is one less than 2^(31).

You can use the numeric_limits<data_type>::min() and numeric_limits<data_type>::max() functions present in limits header file and find the limits of each data type.

#include <iostream>
#include <limits>
using namespace std;
int main()
{
cout<<"Limits of Data types:\n";
cout<<"char\t\t\t: "<<static_cast<int>(numeric_limits<char>::min())<<" to "<<static_cast<int>(numeric_limits<char>::max())<<endl;
cout<<"unsigned char\t\t: "<<static_cast<int>(numeric_limits<unsigned char>::min())<<" to "<<static_cast<int>(numeric_limits<unsigned char>::max())<<endl;
cout<<"short\t\t\t: "<<numeric_limits<short>::min()<<" to "<<numeric_limits<short>::max()<<endl;
cout<<"unsigned short\t\t: "<<numeric_limits<unsigned short>::min()<<" to "<<numeric_limits<unsigned short>::max()<<endl;
cout<<"int\t\t\t: "<<numeric_limits<int>::min()<<" to "<<numeric_limits<int>::max()<<endl;
cout<<"unsigned int\t\t: "<<numeric_limits<unsigned int>::min()<<" to "<<numeric_limits<unsigned int>::max()<<endl;
cout<<"long\t\t\t: "<<numeric_limits<long>::min()<<" to "<<numeric_limits<long>::max()<<endl;
cout<<"unsigned long\t\t: "<<numeric_limits<unsigned long>::min()<<" to "<<numeric_limits<unsigned long>::max()<<endl;
cout<<"long long\t\t: "<<numeric_limits<long long>::min()<<" to "<<numeric_limits<long long>::max()<<endl;
cout<<"unsiged long long\t: "<<numeric_limits<unsigned long long>::min()<<" to "<<numeric_limits<unsigned long long>::max()<<endl;
cout<<"float\t\t\t: "<<numeric_limits<float>::min()<<" to "<<numeric_limits<float>::max()<<endl;
cout<<"double\t\t\t: "<<numeric_limits<double>::min()<<" to "<<numeric_limits<double>::max()<<endl;
cout<<"long double\t\t: "<<numeric_limits<long double>::min()<<" to "<<numeric_limits<long double>::max()<<endl;
}

The output will be: Limits of Data types:

• char : -128 to 127
• unsigned char : 0 to 255
• short : -32768 to 32767
• unsigned short : 0 to 65535
• int : -2147483648 to 2147483647
• unsigned int : 0 to 4294967295
• long : -2147483648 to 2147483647
• unsigned long : 0 to 4294967295
• long long : -9223372036854775808 to 9223372036854775807
• unsigned long long : 0 to 18446744073709551615
• float : 1.17549e-038 to 3.40282e+038
• double : 2.22507e-308 to 1.79769e+308
• long double : 3.3621e-4932 to 1.18973e+4932