Variables in C: Declaring, Initializing, and Assigning

A variable is a named piece of memory that holds a value your program can read and change. In C you always say up front what kind of value it holds, and that choice is permanent for the life of the variable.

Declaring a Variable

The form is type, name, semicolon:

int age;
double price;
char grade;

Each line reserves enough memory for that data type and attaches a name to it. Nothing has been stored yet - the space exists, but its contents are whatever was left there by whatever ran before.

You can give a value at the same moment, which is called initialization:

#include <stdio.h>

int main(void) {
    int age = 30;
    double price = 19.99;
    char grade = 'A';

    printf("Age: %d\n", age);
    printf("Price: %.2f\n", price);
    printf("Grade: %c\n", grade);
    return 0;
}

Note the format specifiers: %d for int, %f for double, %c for char. printf does not inspect the values it is given - it trusts your format string, so a mismatch prints nonsense rather than an error.

Assignment After Declaration

Once a variable exists you change it with =:

#include <stdio.h>

int main(void) {
    int score;      /* declared, value unknown */

    score = 0;      /* assignment */
    printf("Start:  %d\n", score);

    score = 85;     /* assign again - the old value is gone */
    printf("Middle: %d\n", score);

    score = score + 10;   /* read the old value, store the new one */
    printf("End:    %d\n", score);
    return 0;
}

= in C is assignment, not equality. score = score + 10 reads as "take what is in score, add 10, put the result back in score." The comparison operator is ==, and mixing them up is such a common bug that it has its own section on the booleans page.

The shorthand score += 10 does the same thing in fewer characters; the compound assignment operators cover all the arithmetic.

The Uninitialized Variable Trap

This is the single most common beginner bug in C, and it does not produce an error:

#include <stdio.h>

int main(void) {
    int total;      /* never given a value */

    for (int i = 1; i <= 5; i++) {
        total += i; /* reading total before it has a value */
    }

    printf("Total: %d\n", total);
    return 0;
}

Run it. You may see 15, which is the right answer. You may see a huge random number. You may see something different on a second run or on a different machine. All of those are "correct" behavior, because reading an uninitialized local variable is undefined behavior - the C standard places no requirement on what happens.

Unlike many languages, C does not zero your locals. A local variable is a slice of the stack, and the stack is full of leftovers from earlier function calls. Sometimes those leftovers happen to be zero, which is what makes this bug so dangerous: it often works in testing and fails in production.

The fix is one character:

#include <stdio.h>

int main(void) {
    int total = 0;      /* initialized */

    for (int i = 1; i <= 5; i++) {
        total += i;
    }

    printf("Total: %d\n", total);
    return 0;
}

Make it a habit: initialize every variable at the point of declaration. If you genuinely have no sensible value yet, 0 or NULL is better than garbage. And compile with -Wall, which catches most cases:

warning: 'total' is used uninitialized in this function

Global and static variables are the exception - they are zero-initialized automatically. Relying on that is fine, but writing = 0 anyway documents your intent.

Declaring Several at Once

Variables of the same type can share a declaration, with or without initializers:

#include <stdio.h>

int main(void) {
    int x = 1, y = 2, z = 3;
    double width = 4.5, height;   /* height is uninitialized */

    height = 2.0;
    printf("%d %d %d\n", x, y, z);
    printf("area: %.2f\n", width * height);
    return 0;
}

This is legal and common for tightly related values like x, y, z. It is also where a classic misreading lives:

int a = 0, b = 0, c = 0;   /* all three are 0 */
int d, e, f = 0;           /* only f is 0 - d and e are garbage */

The initializer attaches to one name, not to the line. When the values differ in meaning, give each its own line - it reads better and diffs better.

Declaring pointers on one line has the same trap in sharper form:

int *p, q;   /* p is a pointer to int; q is a plain int */

The * binds to the name, not the type. Declare pointers one per line.

Naming Rules and Conventions

The compiler's rules:

• Letters, digits, and underscores only.
• Cannot begin with a digit: total2 is fine, 2total is not.
• Cannot be a C keyword: no variable named int, return, for, double.
• Case sensitive: count, Count, and COUNT are three separate variables.
• Names starting with an underscore, or containing a double underscore, are reserved for the implementation. Do not create them.

int itemCount;       /* legal */
int item_count;      /* legal - the usual C style */
int _count;          /* legal but reserved - avoid */
int item-count;      /* error: '-' is the minus operator */
int 3rd_place;       /* error: starts with a digit */
int float;           /* error: keyword */

The conventions that most C code follows: snake_case for variables and functions, UPPER_CASE for macro constants, and names that say what the value means rather than what type it is. elapsed_ms beats t; customer_count beats n2.

Short names are still fine where the scope is tiny - i as a loop counter is universally understood, and nobody wants for (int loop_iteration_index = 0; ...).

Where a Variable Lives

Where you declare a variable determines who can see it and how long it lasts. This is scope, and the short version is:

#include <stdio.h>

int shared = 100;       /* global: visible to every function in this file */

void show(void) {
    printf("show sees shared = %d\n", shared);
}

int main(void) {
    int local = 5;      /* local to main */

    {
        int inner = 7;  /* local to this block only */
        printf("inner = %d, local = %d\n", inner, local);
    }
    /* inner no longer exists here */

    show();
    printf("main sees local = %d\n", local);
    return 0;
}

A variable is visible from its declaration to the closing brace of the block containing it. Globals live for the whole program and are visible everywhere, which sounds convenient and is why they cause trouble: any function can change one, so tracking down who did becomes a search through the whole file. Prefer locals and pass values to functions as parameters.

Declaring Anywhere (C99 and Later)

In original C89, every declaration had to come before any statement in a block:

int main(void) {
    int i, sum = 0;      /* all declarations first */
    printf("Starting\n");
    for (i = 0; i < 10; i++) { sum += i; }
    return 0;
}

Since C99 you can declare where you first need the value, including in the for header:

#include <stdio.h>

int main(void) {
    printf("Starting\n");

    int sum = 0;                          /* declared where it is needed */
    for (int i = 0; i < 10; i++) {        /* i is scoped to the loop */
        sum += i;
    }

    printf("Sum: %d\n", sum);
    return 0;
}

This is better style: the declaration sits next to its first use, and i cannot leak into the rest of the function. Compile with -std=c17 (or any C99+ setting) and it works everywhere.