You are here: Home » Content » Integer Quantifiers
Content Actions

Integer Quantifiers

Module by: Dr. Duong Tuan Anh

Portable languages like C++ must have flexible data type sizes. Different applications might need integers of different sizes. C++ provides long integer, short integer, and unsigned integer data types. These three additional integer data types are obtained by adding the quantifier long, short or unsigned to the normal integer declaration statements.
Example:
long int days;
unsigned int num_of_days;
The reserved words unsigned int are used to specify an integer that can only store nonnegative numbers.
The signed and unsigned quantifiers tell the compiler how to use the sign bit
with integral types and characters (floating-point numbers always contain a
sign). An unsigned number does not keep track of the sign and thus has an extra
bit available, so it can store positive numbers twice as large as the positive
numbers that can be stored in a signed number.
Figure 1: Integer types with quantifiers
When you are modifying an int with short or long, the keyword int is optional.
Now all the built-in data types provide by C++ are given in the following list, ordered descendingly by the size of the data types.
Data types
--------------
long double
double
float
unsigned long
long int
unsigned int
int
short in
char

Data Type Conversions

An expression containing both integer and floating point operands is called a mixed mode expression.
Example:
int a;
float x = 2.5;
a = x + 6; // x + 6 is a mixed mode expression
Note: We should avoid mixed-mode expression.
Examples:
char Ch;
int In1 = 129, In2, In3;
double Real1 = 12.34, Real2;
What happens with the following mixed mode assignments?
Ch = In1/2 + 1; // Right side = 65; assigns ‘A’ to Ch
In2 = Ch + 1; // Right side = 66; assigns 66 to In2
Real2 = In1/2; // Right side = 64; assigns 64.0 to Real2
In3 = Real1/2.0 // Right side = 6.17; truncates this value and assigns 6 to In3
The general rules for converting integer and floating point operands in mixed mode arithmetic expressions were presented as follows:
  1. If both operands are either character or integer operands:
    • when both operands are character, short or integer data types, the result of the expression is an integer value.
    • when one of the operand is a long integer, the result is a long integer, unless one of the operand is an unsigned integer. In the later case, the other operand is converted to an unsigned integer value and the resulting value of the expression is an unsigned value.
  2. If any one operand is a floating point value:
    • when one or both operands are floats, the result of the operation is a float value;
    • when one or both operands are doubles, the result of the operation is a double value;
    • when one or both operands are long doubles, the result of the operation is a long double value;
Notice that converting values to lower types can result in incorrect values. For example, the floating point value 4.5 gives the value 4 when it is converted to an integer value. The following table lists the built-in data types in order from “highest type” to “lowest type”.

Determining Storage Size

C++ provides an operator for determining the amount of storage your compiler allocates for each data type. This operator, called the sizeof() operator.
Example:
sizeof(num1)
sizeof(int)
sizeof(float)
The item in parentheses can be a variable or a data type.

Example

// Demonstrating the sizeof operator
#include <iostream.h>
int main()
{
char c;
short s;
int i;
long l;
float f;
double d;
long double ld;
cout << "sizeof c = " << sizeof(c)
<< "\tsizeof(char) = " << sizeof( char )
<< "\nsizeof s = " << sizeof(s)
<< "\tsizeof(short) = " << sizeof( short )
<< "\nsizeof i = " << sizeof (i)
<< "\tsizeof(int) = " << sizeof( int )
<< "\nsizeof l = " << sizeof(l)
<< "\tsizeof(long) = " << sizeof( long )
<< "\nsizeof f = " << sizeof (f)
<< "\tsizeof(float) = " << sizeof(float)
<< "\nsizeof d = " << sizeof (d)
<< "\tsizeof(double) = " << sizeof(double)
<< endl;
return 0;
}
The output of the above program:
sizeof c = 1sizeof(char) = 1
sizeof s = 2sizeof(short) = 2
sizeof i = 4sizeof(int) = 4
sizeof l = 4sizeof(long) = 4
sizeof f = 4sizeof(float) = 4
sizeof d = 8sizeof(double) = 8

Comments, questions, feedback, criticisms?

Send feedback