Variables & Data Types

Every program is just data + the operations that move data around. Variables are how you give that data a name. In C, the type system is the contract between you and the compiler — once you declare a variable's type, that type is fixed for life.

Declaration vs Definition vs Initialisation

These three words are used interchangeably in casual conversation but they mean different things:

int x;            // declaration  — "x is an int" (memory reserved, value is GARBAGE)
x = 42;           // assignment   — "put 42 into x"
int y = 42;       // definition + initialisation in one step
extern int z;     // declaration only — "z exists somewhere else, trust me"

> Critical rule: an uninitialised local variable in C does not start at zero. It contains whatever bits were sitting in that memory slot. Reading it is undefined behaviour. Always initialise.

int x;
printf("%d", x);   // ❌ might print 0, might print -873652, might crash

How Many Bytes? Use sizeof

Sizes are not fixed by the C standard — they depend on the compiler and platform. To know the truth on your machine:

printf("int   = %zu bytes\n", sizeof(int));
printf("char  = %zu bytes\n", sizeof(char));   // ALWAYS 1 by definition
printf("float = %zu bytes\n", sizeof(float));
printf("double= %zu bytes\n", sizeof(double));

%zu is the format specifier for size_t (an unsigned integer type returned by sizeof).

Signed vs Unsigned — The Bit-Level Story

A signed 8-bit number uses one bit for the sign, so it stores -128 to 127. An unsigned 8-bit number uses all 8 bits for value, so it stores 0 to 255.

unsigned char u = 200;     // fine
signed   char s = 200;     // ⚠️ overflows to -56 (depends on platform)

Why this matters: if you mix signed and unsigned in the same expression, C silently converts the signed value to unsigned — and a negative number becomes a huge positive one.

unsigned int u = 5;
int s = -3;
if (s < u) printf("yes");
else       printf("no");   // ❌ prints "no" — surprising!

s (-3) is converted to a giant unsigned number before the comparison. Lesson: don't mix signed and unsigned.

Floating-Point Is Not Real Numbers

float and double use the IEEE 754 format. They are accurate enough for most things, but not exact:

printf("%.20f\n", 0.1 + 0.2);   // 0.30000000000000004440

This is not a bug in C — it is fundamental to binary floating-point. Never use == to compare floats. Compare the difference instead:

if (fabs(a - b) < 0.0001) {
    // close enough
}

(fabs lives in — link with -lm on Linux.)

char is just a tiny integer

'A' is not a string — it's the integer 65 with the type char.

char c = 'A';
printf("%c %d\n", c, c);   // A 65

You can do arithmetic on chars:

char letter = 'a' + 3;     // 'd'

This is why ASCII tricks work — characters are numbers.

Type Casting — Telling C "Trust Me"

Sometimes you need to convert between types explicitly:

int   total = 7;
int   count = 2;
double avg  = total / count;          // ❌ 3.0 — integer division happens FIRST
double avg2 = (double)total / count;  // ✅ 3.5

The cast (double) happens before the division, so the division becomes float division.

Constants — Two Ways

const double PI = 3.14159;     // typed constant, lives in memory
#define MAX     1000           // preprocessor — pure text replacement

Rule of thumb: prefer const for values, #define for purely compile-time things and macros.

Putting It Together

#include <stdio.h>
int main(void) {
    int    age   = 19;
    float  cgpa  = 8.7f;
    char   grade = 'A';
    const double PI = 3.14159;
    printf("Age   : %d\n", age);
    printf("CGPA  : %.2f\n", cgpa);     // %.2f → 2 decimal places
    printf("Grade : %c\n", grade);
    printf("Pi    : %lf\n", PI);
    age = age + 1;     // variables CAN change
    // PI = 3.14;      // ❌ compile error: assignment of read-only variable
    return 0;
}

Master this and the rest of C reads like a sentence.