C

Variables, Data Types & Operators

A variable is C's basic unit of storage: a named, fixed-size chunk of memory holding one value of one specific type. This chapter covers how to declare one, what types are actually available, how big each one is, and the operators you use to combine and compare them — the vocabulary every single line of C code after this chapter depends on.

Declaring a variable

Declaring a variable in C always states its type first, then its name, optionally followed by an initial value:

int age = 25;       // type: int,    name: age,    value: 25
char grade = 'B';    // type: char,   name: grade,  value: 'B'
float price = 9.99f; // type: float,  name: price,  value: 9.99
double pi = 3.14159265358979; // type: double, name: pi

Once declared, a variable's type never changes — this is what makes C statically typed. You can change the value stored inside the box, but not what kind of box it is.

The basic data types

Any of the integer types (char, short, int, long) can be prefixed with unsigned to store only non-negative numbers, doubling the positive range in exchange for losing negative values entirely — unsigned int instead of int. The exact bit-level consequences of that trade-off, and the fixed-width types (uint8_t, int32_t, …) that remove the "typical size" guesswork entirely, are covered properly in Embedded C's Data Types & Integer Overflow — worth reading once you're comfortable here, since exact sizes matter far more on a microcontroller than on a desktop.

sizeof — and why it matters

"Typical size" above is deliberately vague, because C never actually guarantees exact sizes — only minimums. The one way to know for certain, on your specific compiler and target, is the built-in sizeof operator:

#include <stdio.h>

int main(void) {
    printf("int is %zu bytes\n", sizeof(int));
    printf("double is %zu bytes\n", sizeof(double));
    return 0;
}
// int is 4 bytes
// double is 8 bytes

This isn't a pedantic detail — code that assumes int is always 4 bytes has genuinely broken on real, shipped hardware where it wasn't. sizeof is how you stop guessing.

Type conversion & casting

C will sometimes convert one type to another automatically (implicit conversion), and you can always force one explicitly (casting):

int a = 7;
int b = 2;
float result = a / b;          // 3.0 — integer division happened BEFORE the assignment
float fixed  = (float)a / b;   // 3.5 — casting a to float first forces floating-point division

(float)a is an explicit cast: "treat this int as a float from this point forward." Without it, C evaluates a / b using integer division first — both operands are integers, so the result is truncated to an integer before it's ever assigned to result.

Operators

Bitwise operators work on the individual bits of a value rather than its numeric meaning — they look unfamiliar at first, but they're the exact tool used to set, clear, and test individual bits in a hardware register, which is why Embedded C's Registers & volatile chapter leans on them constantly.

Operator precedence

When an expression mixes several operators, C evaluates them in a fixed order — not strictly left to right. The rules that matter most day to day:

1. *, /, % bind tighter than +, - — exactly like ordinary arithmetic (2 + 3 * 4 is 14, not 20).
2. Relational (>, ==) bind looser than arithmetic, so a + b > c means (a + b) > c.
3. Logical && binds tighter than logical ||.
4. Bitwise &, ^, | bind looser than relational operators — the single most common precedence mistake in real C code (see Gotchas).
5. When genuinely unsure, add parentheses — they cost nothing at runtime and remove all ambiguity for the next reader, including future you.

Real-world applications

• Sensor reading pipelines — a raw ADC value read as an int is almost always cast to float before being scaled into a real-world unit like volts or degrees.
• Status/flag registers — a single uint8_t or uint32_t variable where each individual bit represents one on/off condition, tested and set with bitwise operators.
• Loop counters and array indices — almost universally plain int, the most common variable type written in any C program.

Gotchas