Why does c plus plus have type modifiers?

Answer 1

There are four modifiers in C++: long, short, signed and unsigned. They are used to modify primitive types (int, char, float and double) to change their behaviour. If no type is specified, int is assumed. Thus a long long turns a 32-bit integer into a 64-bit integer while unsigned ensures an integer is always in the positive range.

Answer 2

There are four type modifiers in C++: signed, unsigned, long and short. They are used to modify the base type to better suit your needs. For instance, when dealing with natural numbers, such as when counting or dealing with file sizes, a plain int is unsuitable because it is implicitly signed and would allow negative values. By modifying the integral to be unsigned you are assured all values will be positive and also double the range of positive integers by utilising the sign bit.

All modifiers can be used with all primitives (integral and arithmetic types) except char which can only be signed or unsigned -- there is no such thing as a short or long char. Also, an unmodified char is a treated as being a completely separate type from signed or unsigned char (whether an unmodified char is signed or unsigned is implementation dependent).

Long and short are seldom used these days because the ISO standard introduced the __int16, __int32 and __int64 data types, which are typically synonymous with short int, long int and long long int respectively. Indeed, the int portion is implicit so needn't be specified at all. Hence many programmers regard short, long and long long as being independent types from int. But they're type modifiers, not types.

Answer 3

C++ allows the char, int, and double data types to have modifiers preceding them. A modifier is used to alter the meaning of the base type so that it more precisely fits the needs of various situations.

The data type modifiers are listed here:

• signed

• unsigned

• long

• short

The modifiers signed, unsigned, long, and shortcan be applied to integer base types. In addition, signedand unsigned can be applied to char, and long can be applied to double.

The modifiers signed and unsigned can also be used as prefix to long or short modifiers. For example unsigned long int.

C++ allows a shorthand notation for declaring unsigned, short, or long integers. You can simply use the word unsigned, short, or long, without the int. The int is implied. For example, the following two statements both declare unsigned integer variables. unsigned x; unsigned int y;

To understand the difference between the way that signed and unsigned integer modifiers are interpreted by C++, you should run the following short program: #include using namespace std; /* This program shows the difference between * signed and unsigned integers. */ int main() { short int i; // a signed short integer short unsigned int j; // an unsigned short integer j = 50000; i = j; cout << i << " " << j; return 0; }

Answer 4

C++ evolved from C and therefore inherits type modifiers from C. The question should really be why does C have type modifiers. However, without type modifiers, the number of primitive type definitions increases from 4 (char, int, float and double) to 18:

int (unmodified)

signed int

unsigned int

long int

signed long int

unsigned long int

long long int

signed long long int

unsigned long long int

short int

signed short int

unsigned short int

char (unmodified)

signed char

unsigned char

float (unmodified)

double (unmodified)

long double

Each of these is really a separate type but there's no need to define separate types when all we really need to do is modify the base type. Thus for the integral data types (int and char) we can cater for 1, 2, 4 and 8 byte data lengths, along with unmodified, signed or unsigned variants, simply by modifying the base type, int. Note that unmodified simply means the sign is compiler-dependent.

Some common types have been defined in the C++ standard, however. These include wchar_t (short int) and size_t (unsigned int). However, there is no standard definition for a 64-bit int (long long int). Some compilers such as MSVC use__int64 (as well as __int8, __int16 and __int32) while others do not. In order to ensure maximum compatibility across all compilers, including C compilers, it is best to use the built-in modifiers or provide your own type definitions.