Type Conversion: Promotion, Casting and Silent Loss

Maria has a stock count of -1 after a bad import, and a check that the count is below a limit of 1u.

She writes count < limit. It is false. Minus one is not less than one, says the program.

Nothing was corrupted. The u on the limit changed which type the comparison happened in, and -1 does not survive that change.

C converts before it operates, always

Almost every C operator needs both operands to be the same type. When they are not, C converts one of them first.

This happens without you asking and without any message. It is called implicit conversion, and it is the subject of this lesson.

Two sets of rules do the work: integer promotion, which happens to small types, and the usual arithmetic conversions, which settle the rest.

Integer promotion: small types are not operated on at all

A char or a short is never the type an arithmetic operator works in. Both are promoted to int first.

#include <stdio.h>

int main(void)
{
    char small = 'A';
    short shorter = 300;

    printf("a char is       %zu byte\n", sizeof(small));
    printf("a short is      %zu bytes\n", sizeof(shorter));
    printf("char + char is  %zu bytes\n", sizeof(small + small));
    printf("short + short is %zu bytes\n", sizeof(shorter + shorter));
    return 0;
}

a char is       1 byte
a short is      2 bytes
char + char is  4 bytes
short + short is 4 bytes

Two one-byte values were added and the answer is four bytes wide. Neither operand was a char by the time the + saw them.

This is good news. It is why 'A' + 1 cannot overflow, and why Module 2's character arithmetic behaved sensibly.

The usual arithmetic conversions, as a ladder

Once both sides are at least int, C picks the higher of the two on this ladder and converts the other one up to it.

The first rung is easy to accept: mix an int with a double and you get a double. Lesson 1's 3.0 was this rule.

The rung between int and unsigned int is the one that costs people money.

Signed meets unsigned, and the sign loses

int and unsigned int are the same width. When they meet, C converts the signed one to unsigned.

Converting -1 to unsigned int does not produce an error or a zero. It produces 4294967295, the largest value that type can hold.

#include <stdio.h>

int main(void)
{
    int count = -1;

    printf("as unsigned  %u\n", (unsigned int)count);
    printf("count < 1u   %d\n", count < 1u);
    printf("count < 1    %d\n", count < 1);
    return 0;
}

as unsigned  4294967295
count < 1u   0
count < 1    1

The middle line is Maria's bug. The comparison is correct arithmetic on the wrong pair of values.

The Playground says nothing at all. A local gcc -Wall reports warning: comparison of integer expressions of different signedness: 'int' and 'unsigned int'.

So the fix is to keep both sides signed, or to cast the unsigned side down on purpose once you know it is small enough.

The cast, and its two honest uses

A cast is you doing the conversion yourself, in writing. It is row 2 of lesson 5's table, so it binds tighter than any arithmetic.

(type)value

(double)total / count      turn one operand into a double, then divide
(int)price                 keep the whole part of a double, on purpose
(unsigned int)n            reinterpret a signed value as unsigned

Two uses are honest. The first is forcing real division, which lesson 1 did with a 3.0 and could not do when the divisor was a variable.

The second is a narrowing you want and are willing to document. (int)price says "I know this loses the fraction, and I mean it".

#include <stdio.h>

int main(void)
{
    int total = 239;
    int count = 3;
    double price = 99.87;

    printf("no cast      %d\n", total / count);
    printf("cast left    %.2f\n", (double)total / count);
    printf("cast outside %.2f\n", (double)(total / count));
    printf("to int       %d\n", (int)price);
    return 0;
}

no cast      79
cast left    79.67
cast outside 79.00
to int       99

The third line is the mistake that looks like the fix. The division finished as integer division before the cast was reached.

A third use, casting to silence a compiler warning you have not understood, is not honest and this track does not do it.

Three silent losses, and where each one happens

None of the three below produces a message on the Playground's command line. Each one is a value leaving through a hole in a type.

• Truncation. A double stored in an int loses its fraction, and it cuts toward zero rather than rounding. 99.87 becomes 99.
• Narrowing. A wide integer stored in a narrow one keeps only the bits that fit. For signed types the result when the value does not fit is implementation defined, and GCC wraps: 300 in a char becomes 44.
• Sign loss. A negative value converted to unsigned becomes a large positive one. This one is fully defined by the standard, which makes it worse: nothing is wrong, so nothing can complain.

A local gcc -Wconversion catches the first two: warning: conversion from 'double' to 'int' may change value. That flag is not in -Wall, and most projects never switch it on.

So the defence is not a compiler flag. It is choosing the type at the point where the value is born, which was Module 2's whole argument.

#include <stdio.h>

int main(void)
{
    int total = 0;
    int count = 0;
    scanf("%d %d", &total, &count);

    printf("%.2f\n", (double)total / count);
    return 0;
}

79.67

#include <stdio.h>

int main(void)
{
    int count = 0;
    scanf("%d", &count);

    printf("against 1   %d\n", count < 1);
    printf("against 1u  %d\n", count < 1u);
    printf("cast fixes  %d\n", count < (int)1u);
    return 0;
}

against 1   1
against 1u  0
cast fixes  1

#include <stdio.h>

int main(void)
{
    double price = 0.0;
    scanf("%lf", &price);

    int taka = (int)price;
    int paisa = (int)(price * 100) - taka * 100;

    printf("%d taka %d paisa\n", taka, paisa);
    return 0;
}

99 taka 87 paisa

int count = -1;
printf("%d\n", count < 1u);

int total = 239;
printf("%.2f\n", (double)(total / 3));

double price = 99.87;
int whole = price;
printf("%d\n", whole);

int big = 300;
char narrow = (char)big;
printf("%d\n", narrow);

#include <stdio.h>

int main(void)
{
    char c = 200;

    printf("%d\n", c);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    int d = 0;
    int e = 0;
    scanf("%d %d %d %d %d", &a, &b, &c, &d, &e);

    /* Add as integers. Then one cast, on one operand of the division. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int n = 0;
    int m = 0;
    scanf("%d %d", &n, &m);

    /* Three lines. The last two reach the same answer by different routes. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    double price = 0.0;
    scanf("%lf", &price);

    /* Two deliberate casts, and one subtraction between them. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int count = 0;
    unsigned int limit = 0;
    scanf("%d %u", &count, &limit);

    /* First line: no cast. Second line: one cast on the limit. */

    return 0;
}

Next comes the module's graded set, where these six lessons meet ten problems and a judge.