C How big a number can an int represent?

ints need to be expressed according to the size of the compiler.

16-bit compiler description: int occupies 16 bits, memory 2 bytes, maximum: 32767;

32-bit and 64-bit compilers: int occupies 32 bits, memory 4 bytes, maximum: 21474836473 the number of bits increases, then the natural number of bits also doubles.

The main reason for determining the maximum value of int varies depending on the compiler type. Therefore, some written programs that cannot be successfully run on the computer are mostly related to the compiler, and may not be the cause of the program. In the general program, the highest bit is the sign bit, and when the number of bits is n, the maximum value is 2 (n-1), which is the n-1 power of 2.

In fact, how big the int is, depends on your system, and the compiler, if you are a 16-bit system, an int is 16 bits, that is, it accounts for 2 bytes, the largest unsigned integer is 2 16, 32 bits is 2 32, long is 32 bits on a 16-bit machine, but due to the distribution of the station, a*10 b should be divided into a, b two parts, so it is not easy to say, the same as int on the 32-bit machine is also 32 bits (but because it is a scientific notation, it is much larger than shaping). Well, if you want to test your machine, the data length can be used.

printf("int length = %d, long length can be known, you might as well try it, that's all.

It's up to your system and compiler. int, 2 bytes or 4 bytes.

int f[1000000];It declares an array, not an integer variable.

Signed short int can express integers ranging from -32768 to 32767

The number of certificates that can be expressed by unsigned short int ranges from 0 to 65535

Signed long int can be expressed in a range from -2147783648 to 2147483647

Unsigned long int can be expressed in a range from 0 to 4294967265

If it overflows outside of the above range, the compiler will assign a value to the overflow variable.

The unsigned int is 0-65535, and the signed int is -32768-32767

The range of unsigned long is 0 to (2 to the 32nd power) minus 1

There is theoretically no upper limit to this, mainly due to the size of your memory.

int f[100000];It's already not going to work. Generally speaking, the space of the array does not need to be so large. The largest I used was 20,000

In C C++, the number of bytes occupied by ints and long ints is dependent on the compiler.

However, most of the commonly used compilers now think that int and long int are the same, both are 4 bytes, short is 2 bytes, and char is 1 byte of Li Ran.

If you only enter int, it can contain all three forms.

Different languages are not the same, e.g. in pascal integer is 2 bytes, byte is 1 byte, and longint is 4 bytes.

It is advisable to refer to the specific help of your compiler for more accurate information.

It's best to use sizeof(int) before using it to see how the current compilation residual burner is defined.

Depending on the program compiler, the number of bytes defined by int varies. (The size of the vertical virtual memory occupied by the data is different).

Commonly used single-chip microcomputer compilers, such as Keil, in the C language of 51 types of microcontrollers, int represents 2 bytes (16 bits); In the case of C for a 32-bit RAM processor, INT stands for 4 bytes (32-bit).

In the PICC of the PIC microcontroller, the int in the C language of the 8-bit series microcontroller represents 16 bits.

On the other hand, the compiler of many PC software will define the int as 8 bytes (64-bit) depending on the operating system or processor (e.g. 64-bit XP).

Therefore, those who program on multiple platforms need to be careful when using it.

If you want to define a 16-digit number, you can use the short (short and short integer type) to define it.

Extended information: In a typical computer, INT occupies 4 bytes and 32 bits

When an unsigned 0 is stored in memory as a binary, each bit is 0, and in the case of a 32-bit int, the binary of (unsigned int) 0 is :

Bitwise negation ( ), becomes:

The decimal system at this point is:

After dividing by 2 (because half of the int type represents a negative number and one more than a positive number), it is:

This is the maximum value of the 32-bit int type.

The largest integer data type in C is the long type, which occupies 4 bytes.

c Medium and short integers both occupy 2 bytes, and the value range is -32768 32767

The long integer type occupies 4 bytes and can be in the range of -2147483648 2147483647

If it is an unsigned number, the data that can be represented is.

Short and integer: 0---65535

Long: 0---4294967295

In C, if a number is large and exceeds the largest long integer, you can use double to store it, which will not affect the calculation accuracy.

In C, the maximum int value is 2147483647.

In C, int, long int, and unsigend long int are all 4 bytes, which can be obtained using the sizeof() function. The maximum number of integers that can be represented by 4 bytes is 2 32 (4 bytes with a total of 32 bits).

int and long int are both signed integer types, so the range of integers they can represent is -2147483648 2147483647, that is, -2 31 2 long int is an unsigned integer type, and the range of integers that can be represented is 0 4294967295, that is, 0 2 32-1.

Similarly, short int is a two-byte signed integer type, and the range of integers that can be represented is 0 65535, that is, 0 2 16-1.

The maximum length of an int is 11 bits. Under a 32-bit machine, the range of ints is - 2 31 2 31 - 1; That is: [-2147483648, 2147483647]; Under a 16-bit machine, the range of int is -2 15 2 15-1.

i.e. :[32768,32767]; The range of the integer variable int is related to the word length of the computer, and the length of int is the length of a computer word.

The number of bytes allowed to be stored in the int type is 4 bytes, which translates to the minimum value of 0 and the maximum value of the int unsigned type is 4294967295 (i.e., 4b = 32b, and the maximum value is 32 1s).

int（

In C, the int() system forces other data types to be converted to int, and the number after the decimal point is rounded without rounding.

For example: int b=10; Declare the variable as int and initialize the assignment.

printf("%f",b*;Printed as a floating-point number, force 10* to result in.

float a=;Declare the variable as a real number and initialize the assignment.

int c=(int) a;Declaring the variable c to be int and forcibly converting a to int assigns the resulting value to c, i.e., c=2

The system will automatically round it up.

For example: int x=;

printf("%d",x);

will output 12.

Example: int( has a value of 7, sum it first, and then force the floating-point type to an integer 7. If there are no parentheses, e.g., (int), then the coercion is converted to 2 first, and then the sum is added, and the result is that when the sum is added, 2 is implicitly converted to floating-point first and then added).

K&R's C programming says that the size of the int is machine-dependent.

#include

#include

int main(void)

The maximum int. can be verified