What are the largest and smallest values that can be reliably stored in a variable of type int?

Answer 1

In C Programming, the range of integer values that we can reliably represent with an int data type is exactly the same as for a char data type: -127 to +127. While an int is usually capable of covering a much wider range of values than a char, this range is the absolute minimum we can guarantee across all C implementations.

Note that while most (all?) modern systems support twos-complement signed notation to yield a minimum range of -128 to +127, we cannot guarantee this range on a ones-complement system because these systems have two separate representations for the value 0, reducing the range by 1 value. 0 is neither positive nor negative, hence the introduction of twos-complement notation.

If we need to determine the maximum guaranteed range we can represent with a built-in type upon any given implementation, then we must use the implementation-defined constants declared in the C standard library header, :

#include

int minimum = INT_MIN;

int maximum = INT_MAX;

Note that on any given system, we can always make the following assertions in C programming:

assert (8<=CHAR_BIT); // CHAR_BIT is defined in

assert (sizeof(char)==1);

assert (sizeof(short)<=sizeof(char));

assert (sizeof(int)<=sizeof(short));

assert (sizeof(long)<=sizeof(int));

assert (sizeof(long long)<=sizeof(long));

These limitations are defined by the C standard. Note that while a char is always 1 byte in length, the length of a byte (in bits) is implementation-defined but is always at least 8 (bits). Systems with 9-bit or 16-bit bytes are not uncommon, but are catered for by the standard. Older systems that support a 7-bit byte are not catered for by the standard, however non-standard implementations do exist to cater for these specific systems.

Answer 2

It depends on the programming language. In C++, all built-in type lengths are implementation defined. However, you can use the implementation itself to determine the limits for any numeric type, like so:

#include<iostream>

#include<limits>

int main() {

std::cout << "Minimum value for int: " << std::numeric_limits<int>::min() << '\n';

std::cout << "Maximum value for int: " << std::numeric_limits<int>::max() << '\n';

}