Ints

Ints are stored differently depending on the language, but are generally 32 bits / 4 bytes of machine code used to represent a signed (meaning including negative) whole number. You can't store decimal values or factions with it (unless the fractions simplify to whole numbers).

//These are valid integers
int population = 100
int populationGrowth= -3

//These are invalid as they are not whole numbers
int averageAge = 35.4
int averageTestScore = 14/20

For instance in C# or Java an int can represent values in the range:

int max = int.MaxValue;
int min = int.MinValue;
Console.WriteLine($"Range of int: {min:N0} to {max:N0}");

Range of int: -2,147,483,648 to 2,147,483,647

For some languages the size of an int is determined by the compiler such as with C++ or is machine dependent like in Swift. There are even some languages like Python where there is no limit on the range of integers it can store.^[1]

Short

In some rare cases you might need to save memory or improve the performance of a particular function. In that case you have the short, 16 bits / 2 bytes of machine code that work the same as an int but can only store numbers in the range:

short max = short.MaxValue;
short min = short.MinValue;
Console.WriteLine($"Range of short: {min:N0} to {max:N0}");

Range of short: -32,768 to 32,767

Long

A long is far more likely to have practical applications, especially when working with very large numbers. It is 64 bits / 8 bytes of machine code that stores signed whole numbers in the absurdly large range:

long max = long.MaxValue;
long min = long.MinValue;
Console.WriteLine($"Range of long: {min:N0} to {max:N0}");

Range of long: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

This can have uses when working with very large numbers although it does take up double the memory of an intso can be quite costly if used in large data structures.

Unsigned

So far all of the integers we've looked at are signed and can have a positive or negative value. If you are looking at a specific case where you won't be using negative numbers then you can use the unsigned variants of int, short and long.

These are uint, ushort and ulong which trade the bit used for denoting a positive or negative integer with doubling the upper limit of the range. Compare the ranges of uint and int:

int max = int.MaxValue;
int min = int.MinValue;
Console.WriteLine($"Range of int: {min:N0} to {max:N0}");

Range of int: -2,147,483,648 to 2,147,483,647

uint max = uint.MaxValue;
uint min = uint.MinValue;
Console.WriteLine($"Range of uint: {min:N0} to {max:N0}");

Range of uint: 0 to 4,294,967,295

Footnotes