char, bool, and the Types That Are Really Numbers

Bob prints his grade with %d instead of %c and gets 65. He restarts the Playground, retypes the program and gets 65 again.

Nothing is broken. He is looking at the same box through a different window, and the box was always holding 65. Module 1 lesson 4 said a char is a small integer; this lesson takes that seriously.

A char is a one byte integer

char is an integer type. It is one byte wide, it holds a small whole number, and printf decides whether you see the number or the shape.

#include <stdio.h>

int main(void)
{
    char grade = 'A';
    char digit = '7';
    char space = ' ';

    printf("grade: %c is %d\n", grade, grade);
    printf("digit: %c is %d\n", digit, digit);
    printf("space: is %d\n", space);
    return 0;
}

grade: A is 65
digit: 7 is 55
space: is 32

Single quotes make a character constant, which is one character and is a number. Double quotes make a string, which is a different thing entirely and belongs to Module 10.

Because it is a number, it does arithmetic. grade + 1 is 66, and printed with %c that is B.

So char is the smallest integer type C has, and the fact that it usually holds a letter is a habit, not a rule.

Is a plain char signed or unsigned? The standard does not say

There are three character types, not one: char, signed char and unsigned char. The first is not the same as either of the others.

Whether plain char can hold a negative value is left to the machine. On the Playground, and on every Intel and AMD desktop, it is signed and runs from -128 to 127. On a Raspberry Pi it is unsigned and runs from 0 to 255.

#include <stdio.h>

int main(void)
{
    char plain = 200;
    signed char definitely_signed = -56;
    unsigned char definitely_unsigned = 200;

    printf("plain char      : %d\n", plain);
    printf("signed char     : %d\n", definitely_signed);
    printf("unsigned char   : %d\n", definitely_unsigned);
    return 0;
}

plain char      : -56
signed char     : -56
unsigned char   : 200

The first two lines agree here and would not agree on an Arm board, where the first line would read 200.

The compiler flag -funsigned-char changes it too, which some projects set on purpose. The Playground does not pass it, so you get the signed reading.

So the rule is: plain char for letters, unsigned char for a raw byte of data, and never a plain char for a value above 127.

bool, true and false, and the header they come from

Old C had no true-or-false type. Zero meant false and everything else meant true, and people wrote int and remembered.

C99 added a real type called _Bool. That name is ugly on purpose, so that existing programs using bool as their own name would keep building. <stdbool.h> then gives you the friendly names.

#include <stdio.h>
#include <stdbool.h>

int main(void)
{
    bool is_enrolled = true;
    bool has_paid = false;

    printf("enrolled : %d\n", is_enrolled);
    printf("paid     : %d\n", has_paid);
    printf("a bool takes %d byte\n", (int)sizeof(bool));
    return 0;
}

enrolled : 1
paid     : 0
a bool takes 1 byte

One byte for one bit of information. A machine cannot address anything smaller, so that is the price.

There is no %b for printing a bool. It is an integer type, so %d is correct, and it prints 1 or 0.

In C23, the newest standard, bool, true and false became keywords and the header stopped being necessary. This track is C17, so the header stays.

Anything that is not zero is true

A bool holds only 1 or 0. Assign it anything else and it collapses to one of those two.

#include <stdio.h>
#include <stdbool.h>

int main(void)
{
    bool from_seven = 7;
    bool from_minus = -7;
    bool from_zero = 0;

    printf("7  becomes %d\n", from_seven);
    printf("-7 becomes %d\n", from_minus);
    printf("0  becomes %d\n", from_zero);
    return 0;
}

7  becomes 1
-7 becomes 1
0  becomes 0

Read the middle line twice. Negative numbers are true. Only zero is false, and there is exactly one false value in the whole language.

So "is it true" and "is it positive" are different questions, and mixing them up is a bug that Module 5 will let you write.

A comparison is an expression, and its value is 1 or 0

This is the piece most beginners never get told, and it makes half of C easier to read.

a < b is not a special thing that only lives inside an if. It is an expression with a value, of type int, and that value is 1 when the comparison holds and 0 when it does not.

#include <stdio.h>

int main(void)
{
    char ch = '5';

    printf("is it at least '0' ? %d\n", ch >= '0');
    printf("is it at most  '9' ? %d\n", ch <= '9');
    printf("both of those       ? %d\n", (ch >= '0') * (ch <= '9'));
    return 0;
}

is it at least '0' ? 1
is it at most  '9' ? 1
both of those       ? 1

The third line multiplies two answers that are each 1 or 0. The product is 1 only when both are 1, which is exactly "and".

C has a proper operator for that, written &&, and Module 4 introduces it with the rest of the operators. Multiplying works today and shows you what is underneath.

So a comparison is a number, and numbers can be added, multiplied and printed. You will use that in the exercises below.

One paragraph on enum

There is a fourth type that is really a number: enum. It gives readable names to a list of whole numbers, starting at 0 and counting up.

#include <stdio.h>

int main(void)
{
    enum weekday { sunday, monday, tuesday, wednesday };
    enum weekday today = wednesday;

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

today = 3

wednesday is the fourth name, so it is 3. Module 12 builds on this properly, alongside struct. It is here so that the sentence "the types that are really numbers" is complete.

#include <stdio.h>

int main(void)
{
    char ch = 'P';

    printf("as a character: %c\n", ch);
    printf("as a number   : %d\n", ch);
    printf("the next one  : %c\n", ch + 1);
    return 0;
}

as a character: P
as a number   : 80
the next one  : Q

#include <stdio.h>
#include <stdbool.h>

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

    bool has_passed = marks >= 40;

    printf("marks  : %d\n", marks);
    printf("passed : %d\n", has_passed);
    return 0;
}

marks  : 39
passed : 0

#include <stdio.h>

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

    int count = (a >= '0') * (a <= '9')
              + (b >= '0') * (b <= '9')
              + (c >= '0') * (c <= '9');

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

2

char grade = "A";
printf("%d\n", grade);

char grade = 'ab';
printf("%d\n", grade);

int main(void)
{
    bool ok = 1;
    return ok;
}

char byte_value = 200;
printf("%d\n", byte_value);

#include <stdio.h>

int main(void)
{
    int x = 7;

    if (x = 0) {
        printf("x was zero\n");
    }

    printf("x is now %d\n", x);
    return 0;
}

#include <stdio.h>

int main(void)
{
    char ch = 0;
    scanf("%c", &ch);

    /* Two comparisons multiplied together, printed with %d. */

    return 0;
}

#include <stdio.h>

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

    /* Three of Exercise 1's answers, added. */

    return 0;
}

#include <stdio.h>

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

    /* No loop. What is left over when n is divided by 2? */

    return 0;
}

Next you stop taking any of these sizes on trust, and ask the machine itself.