Constants. Variables.

1Lab objectives

• Writing integer constants in bases 10, 8, and 16, and using the U and L suffixes
• Using real, character, and string constants, including escape sequences
• Declaring variables with the type suited to the range of values
• Experimentally determining sizes with the sizeof operator
• Telling scope apart from a variable's lifetime

2Constants

Literal constants are fixed values that cannot be changed during execution. Their type is determined automatically by the compiler, based on the value and the syntax used.

Integer constants

Default type determination

The default type can be forced with suffixes: U/u for unsigned, L/l for long, combined as UL.

Character constants and escape sequences

3Fundamental data types

4Variables

Declaring a variable reserves space in memory and associates it with a name and a type:

type name;                 // simple declaration, undefined value
type name = value;         // declaration with initialization
type n1, n2, n3;           // several variables of the same type
const type name = value;   // a value that can no longer be changed

5Scope and lifetime

6Execution simulator

Watch step by step how an ordinary local variable behaves compared to one declared static, over three successive calls of the same function.

7Source code

#include <stdio.h>
#include <limits.h>

int main(void)
{
    printf("Type           Bytes   Min                Max\n");
    printf("-------------------------------------------------------\n");
    printf("char           %2zu     %-18d %d\n", sizeof(char),  CHAR_MIN,  CHAR_MAX);
    printf("short          %2zu     %-18d %d\n", sizeof(short), SHRT_MIN,  SHRT_MAX);
    printf("int            %2zu     %-18d %d\n", sizeof(int),   INT_MIN,   INT_MAX);
    printf("long           %2zu     %-18ld %ld\n", sizeof(long), LONG_MIN, LONG_MAX);
    printf("float          %2zu\n", sizeof(float));
    printf("double         %2zu\n", sizeof(double));

    return 0;
}

#include <stdio.h>

int main(void)
{
    int decimal     = 100;      // base 10
    int octal       = 0144;     // base 8  -> also 100
    int hexadecimal = 0x64;     // base 16 -> also 100

    printf("%d %d %d\n", decimal, octal, hexadecimal);   // 100 100 100

    // the same value shown in different bases
    printf("decimal: %d   octal: %o   hex: %X\n", 255, 255, 255);

    // the leading-zero trap
    int wrong = 010;
    printf("010 means %d, not 10!\n", wrong);            // 8

    // character vs string
    char c = 'A';
    char s[] = "A";
    printf("sizeof('A') in C = %zu, sizeof(\"A\") = %zu\n", sizeof(c), sizeof(s));

    return 0;
}

#include <stdio.h>

int main(void)
{
    short small = 32767;        // the maximum value for short
    printf("before: %d\n", small);
    small = small + 1;          // overflow!
    printf("after +1: %d\n", small);   // -32768, drops to the minimum value

    unsigned char u = 255;
    u = u + 1;
    printf("unsigned char 255+1 = %u\n", u);   // 0, wraps back to the start

    return 0;
}

8Code workshop

The sizes of types and their overflow behavior are not learned from tables, but by seeing them. Run the programs below and change the values to see exactly where each type breaks.

#include <stdio.h>

int main(void)
{
    printf("char        %d byte(s)\n", (int)sizeof(char));
    printf("short       %d byte(s)\n", (int)sizeof(short));
    printf("int         %d byte(s)\n", (int)sizeof(int));
    printf("long long   %d byte(s)\n", (int)sizeof(long long));
    printf("float       %d byte(s)\n", (int)sizeof(float));
    printf("double      %d byte(s)\n", (int)sizeof(double));

    printf("\nConstants written in different bases:\n");
    printf("  67 decimal = %d\n", 67);
    printf("  0103 octal = %d\n", 0103);
    printf("  0x43 hex   = %d\n", 0x43);
    printf("  'C' is     = %d\n", 'C');
    return 0;
}

#include <stdio.h>

int main(void)
{
    short s = 32767;          /* the maximum value for short */
    printf("s        = %d\n", s);
    s = s + 1;
    printf("s + 1    = %d   <- became negative!\n", s);

    unsigned char u = 255;
    printf("\nu        = %d\n", u);
    u = u + 1;
    printf("u + 1    = %d   <- wrapped back to zero\n", u);

    char c = 200;             /* 200 does not fit in a signed char */
    printf("\nchar c   = %d\n", c);
    return 0;
}

9Work tasks

• Run the size-checking program and note down the values obtained on the lab computer.
• Write the value 200 in bases 10, 8, and 16 and check that the printed result is identical.
• Declare a short variable with the maximum value and add 1; explain the result.
• Compare sizeof('A') in C with sizeof('A') in C++ - the results differ, explain why.
• Write a function with a static counter and call it five times; print the value on each call.
• Declare an uninitialized local variable, print it, and run the program three times - see whether the value changes.
• Use all the escape sequences from the table in a single printf and observe the effect.

10Extended application

11Review questions

12Resources

• This lab's handout (PDF)
• The course page - all materials