C++ Data Type Modifiers

Except type void, the basic data types may have various modifiers preceding them. You use a modifier to alter the meaning of the base type to fit various situations more precisely. The list of modifiers are as follows :

• signed
• unsigned
• long
• short

You can apply the modifiers signed, unsigned, short, and long to character and integer base types. However, you may also apply long to double.

Note - ANSI standard eliminates long float because it is nothing but double.

Computer memory is organized into units called bytes. A byte consists of 8-bits, where a bit is the smallest unit of memory. 1 bit can represent 2 unique combinations of binary numbers (0 and 1) ie., 2¹, 2 bits can represent 4 unique combinations of binary number (00, 01, 10, 11) i.e., 2² and so on. Thus, a byte (8 bits) can represent 2⁸ = 256 unique number of combinations Two-byte unit can represent 65536 (2¹⁶) different values, and a four-byte unit can represent 4,294,672,296 (2³²) different values.

Integer Type Modifiers

By using different number of bytes to store values, C++ offers three types of integers : short, int, and long that can represent up to three different integer sizes. Each comes in both signed and unsigned versions. That gives you a choice of six different integer types. The sizes of these integer types can vary across different computer systems, however, C++ offers a flexible standard with some guaranteed minimum sizes, which are as follows:
A short integer is at least two bytes.
An int integer is at least as big as short.
A long is at least four bytes and at least as big as int.

Note - short is short name for short int and long is short name for long int.

The prefix unsigned makes the integer type not to hold negative values. For instance, if short (2-byte long) represents the range -32768 to +32767, then the unsigned version can represent the range 0 to 65535. This has the advantage of increasing the largest value the variables can hold. Unsigned type are used for quantities that are never negative such as populations, sports scores, inventory counts etc.

The following table summarizes different integer types, their sizes and minimal range they can hold :

As obvious from the above table that short, int, and long are signed by default.

Character Type Modifiers

The char type is really another integer type (as inside memory it actually holds numbers i.e., equivalent codes of characters/symbols). It is guaranteed to be large enough to represent the entire range of basic symbols - all the letters, digits, punctuation and the like - for the target computer system. A single byte can represent the whole range of 256 known characters.

The char type can also be signed or unsigned. Unlike int, char is neither signed nor unsigned by default. The choice is left to the C++ implementation in order to allow the implementer to best fit the type to the hardware properties.

However, these distinctions are particularly important if you are using char as a numeric type. The unsigned char represents the range 0 to 256 and signed char represents the range -128 to 127.

The following table summarizes the character types and their minimal ranges :

Floating-point Type Modifiers

C++ has three floating-point types: float, double and long double.

Note - Double is another floating-point type it is none other than long float.

These types are described in terms of the number of significant features they can represent and the minimum allowable range of exponents. The type float occupies 4 bytes of memory. Type double occupies 8 bytes, twice as much memory as type float and stores floating-point numbers with much larger range and precision. Floating-point type long double occupies 10 bytes and has only slightly greater range and precision than type double.

Following table summarises floating-point types and the minimal range of values they can hold :

Note - Some implementation may allow you to apply unsigned to the floating-point types (as in unsigned double). However, this reduces the portability of your code and is generally not recommended.

Note - One thing that you must ensure is not to put commas in numeric values.

Type Qualifiers in C++

The type qualifiers provide additional information about the variables they precede.

Examples

Here are some C++ example programs listed, that you can go for:

• Add two Numbers
• Check Even or Odd
• Check Prime or Not
• Check Alphabet or Not
• Check Vowel or Not
• Check Leap Year or Not
• Pattern Programs
• Print Diamond Pattern
• Print Floyd Triangle
• Print Pascal Triangle
• Print Fibonacci Series
• Check Palindrome or Not
• Check Armstrong or Not
• Generate Armstrong Numbers
• Find ncR nPr
• Print Table of Number
• Print Prime Numbers
• Add n Numbers
• Interchange Numbers
• Reverse Numbers
• Swap two Numbers

C++ Online Test

---

« Previous Tutorial Next Tutorial »

---

---