Promotion and Conversion

When Everything is the Same Type

Everything is easiest when we're working with the same type, so…

• An int added to an int makes an int
• A long double added to a long double makes a long double.

So if we say

long usPopulation    = 336858333;
long usAreaInSqMiles = 3718712;
std::cout << "People per square mile = "
          << usPopulation/usAreaInSqMiles
          << std::endl;

the calculation usPopulation/usAreaInSqMiles takes in two longs and the result is a long. So it will print

People per square mile = 90

If, however, we'd instead said

double usPopulation    = 336858333.0;
double usAreaInSqMiles = 3718712.0;
std::cout << "People per square mile = "
          << usPopulation/usAreaInSqMiles
          << std::endl;

it would have used double's division operator and produced the output:

People per square mile = 90.5847

Promotion: Different Sizes of the Same Type

Let's assume that long is a bigger type than int (specifically, that we're using the LP64 memory model where int is 32 bits and long is 64 bits.).

If we do something like:

long usPopulation   = 336858333;
int thisWeeksGain   = 36538;
std::cout << "US population is now "
          << usPopulation + thisWeeksGain
          << std::endl;

C++ does the sensible thing, it takes the int holding thisWeeksGain and widens it to be a long before it adds it to usPopulation, so the final result we're printing is a long. This widening process is called a promotion.

It would also be considered a promotion if we had declared thisWeeksGain as an unsigned int, so long as it's smaller than a long. This is because the range of an unsigned int is [0…4,294,967,297] and the range of a long is [−9,223,372,036,854,775,808…9,223,372,036,854,775,807], so the range of an unsigned int falls entirely inside the range of a long.

C++ performs promotions automatically, and its rule for promotion is

• The types must be the same kind (integer to integer or floating point to floating point).
• The range of the type being promoted to must completely include the range of the type being promoted from.

Thus, a promotion cannot ever cause information to be lost.

Any other kind of conversion between numeric types is a conversion.

We can also get C++ to perform promotions when we initialize new variables.

short weekDay = 3;
int yearStart = weekDay;

Explicit Promotions

We can also perform promotions explicitly. For example,

signed char dollar = 36;
std::cout << "Printed as a character " << dollar << std::endl
          << "Printed as an integer  " << int(dollar) << std::endl;

prints

Printed as a character $
Printed as an integer  36

Conversion: Changing Between Types

If we move a numeric value between types and it isn't a promotion, it's a conversion.

Suppose instead we had written

double usPopulation = 336858333;
int thisWeeksGain   = 36538;
std::cout << "US population is now "
          << usPopulation + thisWeeksGain
          << std::endl;

Here C++ would have to make a choice for what type the result of usPopulation + thisWeeksGain should be. Given a choice between an int and a double for the result of the addition, it converts the type to a double.

If we run this code

long worldPop = 7960583250;
std::cout << "World pop as long " << worldPop << std::endl
          << "----------> float " << float(worldPop) << std::endl
          << "-----------> long " << long(float(worldPop)) << std::endl;

it prints

World pop as long 7960583250
----------> float 7.96058e+09
-----------> long 7960583168

Some rules:

• Conversions (and promotions) often happen automatically, particularly when we call a function that wants a different type from the one we're providing but we can convert our value to that type.
• Changing any kind of integer to any kind of float (or the other way) is always considered a conversion (even if on a particular machine no information could be lost for those particular sizes, so char→double is still a conversion).
• Changing to a smaller incarnation of the basic type is always a conversion (e.g., int→short int or double→float).
• Signed→unsigned is always a conversion (e.g., short int→unsigned long int is a conversion).
• Unsigned→signed is usually a conversion (unless the signed type is larger, which it usually isn't).

Conversions and Promotions Aren't Done “Early”

While conversions and promotions happen automatically, they happen no earlier than needed. So if we say:

long usPopulation    = 336858333;
long usAreaInSqMiles = 3718712;
double popPerSqMile  = usPopulation/usAreaInSqMiles;

It will first perform division on longs to produce a long result and only afterwards will it convert it to a double. To get a double as the result from division, we need to be dividing doubles.

So we need to write:

long usPopulation    = 336858333;
long usAreaInSqMiles = 3718712;
double popPerSqMile  = double(usPopulation) / double(usAreaInSqMiles);

Summary: Promotion and Conversion

(When logged in, completion status appears here.)