🌱 C Basics

Variables & types: naming your bytes

⏱ 15 min · free interactive lesson · quizzes, visualizations & a real compiler

A program that only prints fixed text is a very expensive poster. Real programs remember things — and in C, memory you can name is a variable. Because C works directly with the machine's memory, every variable has a type that decides two things: how many bytes it occupies (remember from Part 0 — a byte is 8 bits), and how those bytes are interpreted (integer? real number? character?).

Declaring variables

The pattern is type name = value; — the type comes first, then your chosen name, then (optionally, but wisely) an initial value:

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

int main(void) {
    int age = 42;                /* whole number             */
    char grade = 'A';            /* one character (really a  */
                                 /*   small integer: 65)     */
    double pi = 3.14159;         /* real number              */
    bool hungry = true;          /* 1 or 0                   */
    unsigned int stars = 4000000000u;  /* no negatives, more room */

    printf("age    = %d\n", age);
    printf("grade  = %c (which is %d)\n", grade, grade);
    printf("pi     = %.5f\n", pi);
    printf("hungry = %d\n", hungry);
    printf("stars  = %u\n", stars);
    return 0;
}

$ gcc variables.c -o variables && ./variables
age    = 42
grade  = A (which is 65)
pi     = 3.14159
hungry = 1
stars  = 4000000000

The integer family

C offers a whole wardrobe of integer types, from small to huge. The keywords short, long, and long long modify int; signed and unsigned choose whether the two's-complement sign bit is used (remember Part 0?):

Notice the weasel words: the standard only sets minimums. Actual sizes are implementation-defined — chosen by your compiler and platform. Even whether a plain char is signed or unsigned is implementation-defined! When exact sizes matter (file formats, networking), you'll later use int32_t friends from <stdint.h>.

Real numbers and truth values

• float — 32-bit IEEE-754, ~7 significant digits.
• double — 64-bit, ~15–16 digits. The default choice; literals like 3.14 are doubles.
• _Bool — C99's built-in boolean, holding only 0 or 1. Include <stdbool.h> to spell it bool with true/false — and in C23, bool, true, false are finally real keywords on their own.

How big is it really? Ask sizeof

The sizeof operator (a real C keyword, evaluated at compile time) tells you the size of any type or expression in bytes:

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

int main(void) {
    printf("char      : %zu byte\n",  sizeof(char));
    printf("short     : %zu bytes\n", sizeof(short));
    printf("int       : %zu bytes\n", sizeof(int));
    printf("long      : %zu bytes\n", sizeof(long));
    printf("long long : %zu bytes\n", sizeof(long long));
    printf("float     : %zu bytes\n", sizeof(float));
    printf("double    : %zu bytes\n", sizeof(double));
    printf("bool      : %zu byte\n",  sizeof(bool));
    return 0;
}

$ gcc sizes.c -o sizes && ./sizes
char      : 1 byte
short     : 2 bytes
int       : 4 bytes
long      : 8 bytes
long long : 8 bytes
float     : 4 bytes
double    : 8 bytes
bool      : 1 byte
# your numbers may differ — that's the "implementation-defined" part!

One guarantee is carved in stone: sizeof(char) is always 1 — by definition. Everything else, verify on your platform.

Variables live at addresses

Each variable claims a chunk of stack memory sized to its type. Here's roughly what the variables from our first example look like in RAM:

▶ This spot has an interactive memgrid widget — open the interactive lesson to play with it.

printf's secret language: format specifiers

printf can't guess types — you must tell it what you're passing with % placeholders:

▶ This spot has an interactive editor widget — open the interactive lesson to play with it.

Variables are lovely, but inert. Time to do things to them: arithmetic operators await.