C Data Types - Uninitialized Var Causes Random Interest

Every program that has ever run on a computer — from the app on your phone to the code launching rockets — stores information somewhere while it's working. That 'somewhere' is memory, and the mechanism C gives you to work with memory is variables. Without them you can't remember a user's name, keep score in a game, or total up a shopping cart. They are the absolute foundation everything else is built on.

The problem variables solve is simple: programs need to hold onto values while they're doing work. Without variables you'd have to hard-code every number directly into your logic, and the moment anything changed you'd be stuck. Data types solve a second problem: memory is finite and expensive, so C forces you to say upfront exactly how much space each value needs. A yes/no flag doesn't need the same amount of memory as a GPS coordinate, and C respects that.

By the end of this article you'll be able to declare any basic variable in C, pick the right data type for the job, read and write to variables with confidence, understand exactly how much memory each type consumes, and avoid the three traps that catch nearly every beginner. Let's build this from the ground up.

What a Variable Actually Is — And How C Stores It in Memory

When your C program runs, the operating system hands it a chunk of RAM to work with. Think of that RAM as a very long row of tiny boxes, each holding exactly one byte (8 bits), and each box having its own unique address — like house numbers on a street.

A variable is your way of reserving one or more of those boxes and giving them a human-readable name. When you write int playerScore = 0;, C reserves 4 boxes (4 bytes) in a row, remembers where they start, and every time you write playerScore in your code it knows exactly which boxes to look in.

The name only exists for you. The computer only ever works with addresses. C's compiler is the translator between your human-friendly name and the raw memory address. This is why you have to declare a variable before you use it — you're asking C to go find and reserve the space before you try to put something there.

Declaration syntax is always the same pattern: datatype variableName; or datatype variableName = initialValue;. The second form is called initialization and it's always the safer choice, as you'll see in the mistakes section.

#include <stdio.h>

int main() {
    /* Declare an integer variable to store a player's score.
       C reserves 4 bytes in memory and labels them 'playerScore'. */
    int playerScore = 100;

    /* Declare a character variable to store a grade letter.
       C reserves 1 byte in memory for a single character. */
    char letterGrade = 'A';

    /* The & operator gives us the actual memory address C chose.
       %p is the format specifier for printing an address (pointer). */
    printf("Value of playerScore : %d\n", playerScore);
    printf("Address in RAM       : %p\n", (void*)&playerScore);

    printf("Value of letterGrade : %c\n", letterGrade);
    printf("Address in RAM       : %p\n", (void*)&letterGrade);

    /* How many bytes does each type occupy on this machine? */
    printf("\nSize of int  : %zu bytes\n", sizeof(int));
    printf("Size of char : %zu bytes\n", sizeof(char));

    return 0;
}

The Four Core Data Types in C — Choosing the Right Locker for the Job

C has four fundamental data types you'll use in 90% of your programs. Every other type is either a variation or a combination of these four.

int (integer) — For whole numbers, positive or negative. No decimal point. Use this for counts, ages, loop counters, scores, anything you'd count on your fingers. Typically 4 bytes, holding values from roughly -2.1 billion to +2.1 billion.

float (floating-point) — For numbers with a decimal point where you need about 6–7 digits of precision. Think currency, temperature, measurements. Typically 4 bytes. The trade-off: floats have small rounding errors baked in — more on that in the gotchas.

double (double-precision float) — Like float but twice the size (8 bytes) and roughly 15–16 digits of precision. Use this whenever float's precision feels risky — scientific calculations, financial totals, GPS coordinates. In modern code, prefer double over float unless memory is critically tight.

char (character) — For a single letter, digit, or symbol. Under the hood it's just a tiny integer (1 byte) that maps to a character via the ASCII table. 'A' is stored as the number 65. This duality is surprisingly powerful and comes up in interviews constantly.

#include <stdio.h>

int main() {
    /* --- INTEGER: whole numbers only --- */
    int numberOfStudents = 42;
    int freezingPointCelsius = 0;
    int bankDebtDollars = -5000;   /* negatives work fine */

    /* --- FLOAT: decimals with ~6 significant digits --- */
    float bodyTemperatureCelsius = 36.6f;  /* note the 'f' suffix — required for float literals */
    float taxRate = 0.085f;

    /* --- DOUBLE: decimals with ~15 significant digits --- */
    double distanceToMoonKm = 384400.0;
    double piApproximation = 3.14159265358979;

    /* --- CHAR: single characters, stored as ASCII numbers --- */
    char bloodType = 'O';
    char newlineCharacter = '\n';  /* special 'escape' characters use backslash */

    /* --- Print everything out with the matching format specifier --- */
    printf("Students       : %d\n",  numberOfStudents);     /* %d  for int    */
    printf("Freezing point : %d C\n", freezingPointCelsius);
    printf("Bank debt      : %d USD\n", bankDebtDollars);

    printf("Body temp      : %.1f C\n", bodyTemperatureCelsius);  /* %.1f = 1 decimal place */
    printf("Tax rate       : %.3f\n",  taxRate);

    printf("Moon distance  : %.1f km\n", distanceToMoonKm);  /* %f also works for double */
    printf("Pi             : %.14f\n", piApproximation);      /* 14 decimal places */

    printf("Blood type     : %c\n",  bloodType);             /* %c  for char   */

    /* char stores an ASCII integer — we can print it both ways */
    printf("'O' as a number: %d\n",  bloodType);             /* prints 79 */

    return 0;
}

Type Modifiers — Stretching and Shrinking Your Data Types

The four core types are good starting points, but C lets you tune them further using four modifiers: short, long, signed, and unsigned. Think of these as choosing between locker sizes at the gym — small, standard, large, and extra-large.

short int uses 2 bytes instead of 4, halving your range but saving memory. Useful in embedded systems where every byte is precious — think microcontrollers in toasters or car sensors.

long int typically gives you 4 or 8 bytes (platform-dependent), and long long int guarantees at least 8 bytes. Use long long when you need numbers beyond 2 billion — population counts, file sizes in bytes, Unix timestamps.

unsigned removes the ability to store negative numbers but doubles the positive range. A regular int goes from about -2.1B to +2.1B. An unsigned int goes from 0 to about 4.2B. Use it when a negative value is physically impossible — array sizes, pixel counts, ages.

signed is the default for all integer types, so you rarely need to write it explicitly. It exists mainly for clarity or when working with char, which can be signed or unsigned depending on the compiler.

#include <stdio.h>

int main() {
    /* short int: 2 bytes — good for small whole numbers */
    short int floorNumber = 12;

    /* long long int: 8 bytes — for very large whole numbers */
    long long int worldPopulation = 8100000000LL;  /* LL suffix required for long long literals */

    /* unsigned int: 4 bytes, but 0 to ~4.29 billion (no negatives) */
    unsigned int numberOfPixels = 2073600;  /* 1920 x 1080 */

    /* unsigned char: 1 byte, values 0–255 — perfect for RGB color components */
    unsigned char redChannel   = 255;
    unsigned char greenChannel = 128;
    unsigned char blueChannel  = 0;

    printf("Floor number    : %hd\n",   floorNumber);       /* %hd for short */
    printf("World population: %lld\n",  worldPopulation);   /* %lld for long long */
    printf("Pixel count     : %u\n",    numberOfPixels);    /* %u for unsigned int */
    printf("RGB color       : (%u, %u, %u)\n", redChannel, greenChannel, blueChannel);

    /* sizeof confirms the memory footprint */
    printf("\nMemory sizes:\n");
    printf("  short int      : %zu bytes\n", sizeof(short int));
    printf("  int            : %zu bytes\n", sizeof(int));
    printf("  long long int  : %zu bytes\n", sizeof(long long int));
    printf("  unsigned char  : %zu bytes\n", sizeof(unsigned char));

    return 0;
}

Naming Rules, Constants, and Writing Variables That Future-You Will Thank You For

C has strict rules about what you can name a variable, and there are strong conventions on top of those rules. Breaking the rules causes compile errors. Ignoring the conventions causes something worse: unreadable code.

Hard rules: Variable names can only contain letters (a–z, A–Z), digits (0–9), and underscores (_). They must start with a letter or underscore — never a digit. They can't be C keywords like int, return, or for. C is case-sensitive, so score, Score, and SCORE are three completely different variables.

Convention: Most C programmers use snake_case for variable names — all lowercase with underscores between words. playerScore (camelCase) is also common, especially for developers coming from C++ or Java. Pick one and stick to it in a project.

Constants with const: If a value should never change after it's set, mark it const. The compiler will stop you if you accidentally try to change it. This is much better than a raw number buried in your code — called a 'magic number' — which gives future readers zero context about what 3.14159 or 9.81 means.

Use #define for compile-time constants that you want available everywhere in the file, and const for constants that live in a specific scope.

#include <stdio.h>

/* #define creates a compile-time constant — no memory is allocated,
   the preprocessor replaces every occurrence before compilation */
#define MAX_SPEED_KMH     120
#define GRAVITY_MS2       9.81

int main() {
    /* const creates a runtime constant — memory IS allocated,
       but the compiler refuses any attempt to change the value */
    const float PI = 3.14159f;
    const int   DAYS_IN_WEEK = 7;

    /* Good naming: reads like plain English */
    int currentSpeedKmh    = 95;
    float circleRadiusMetres = 5.0f;
    int daysUntilDeadline  = 14;

    /* Calculate using our named constants — clear and self-documenting */
    float circumference = 2 * PI * circleRadiusMetres;
    int weeksUntilDeadline = daysUntilDeadline / DAYS_IN_WEEK;
    int speedHeadroom = MAX_SPEED_KMH - currentSpeedKmh;

    printf("Circle circumference : %.2f metres\n", circumference);
    printf("Weeks until deadline : %d\n",          weeksUntilDeadline);
    printf("Speed headroom       : %d km/h\n",     speedHeadroom);
    printf("Gravity constant     : %.2f m/s^2\n",  GRAVITY_MS2);

    /* This line would cause a COMPILE ERROR — uncomment to see:
       PI = 3.14;   // error: assignment of read-only variable 'PI' */

    return 0;
}

Common Variable Pitfalls That Crash Production

Even after learning the rules, beginners (and sometimes experts) make the same mistakes over and over. These aren't just learning errors — they cause real production outages.

Uninitialized memory: C does not zero local variables. A declaration like int count; gives you whatever bits happened to be in that stack location. Using it before assignment is undefined behavior. In some runs it works, in others it produces garbage. These bugs are notoriously hard to reproduce.

Integer overflow: When a value exceeds the type's maximum, it wraps around. short x = 32767; x++; gives -32768. No warning, no crash — just a wrong answer. This has caused rocket explosions and financial disasters.

Format specifier mismatch: Using %f with an integer or %d with a float tells printf to interpret the bits in the wrong way. Stack corruption and silent data corruption follow. The compiler with -Wformat catches this. Always compile with warnings enabled.

Integer division: int a = 5; int b = 2; double result = a / b; gives 2.0, not 2.5. The division happens with integers first, then the integer result is converted. Cast at least one operand to float or double.

#include <stdio.h>

int main() {
    /* Pitfall 1: Uninitialized variable */
    int uninitialized;  /* dangerous — may be 0, may be garbage */
    printf("Pitfall 1: %d\n", uninitialized);  // undefined behavior

    /* Pitfall 2: Integer overflow */
    short smallCounter = 32767;
    smallCounter = smallCounter + 1;
    printf("Pitfall 2: %d\n", smallCounter);  // prints -32768

    /* Pitfall 3: Format specifier mismatch */
    int anInt = 42;
    // printf("%f\n", anInt);  // uncomment to see garbage (or crash)

    /* Pitfall 4: Integer division truncation */
    int a = 5, b = 2;
    double badResult = a / b;          // 2.0
    double goodResult = (double)a / b; // 2.5
    printf("Pitfall 4: bad=%.1f, good=%.1f\n", badResult, goodResult);

    return 0;
}

Type Conversion and Casting — When the Compiler Changes Your Data

C performs implicit type conversion in many situations: when you assign a value to a variable of a different type, when you mix types in expressions, or when you pass arguments to functions. Understanding these conversions prevents unexpected data loss.

Implicit conversion (promotion): In expressions, smaller types are promoted to larger ones. For example, a char is promoted to int in arithmetic. This usually works fine. But assignments are different: if you assign a double to an int, the fractional part is truncated (not rounded).

Explicit casting: You can force a conversion using the cast operator: (type)expression. Always do this when you know the conversion might lose information — it documents your intent and warns other developers.

Integer promotion rules: Operations on char and short are performed in int (or unsigned int). This can cause subtle bugs: unsigned char a = 250; unsigned char b = 10; int c = a - b; works fine, but c = a - 300; may produce unexpected results because 300 is an int and the subtraction is performed in int.

Truncation and sign extension: When converting from a larger signed type to a smaller one, the high-order bits are discarded. For unsigned types, sign extension occurs when converting from signed to unsigned.

#include <stdio.h>

int main() {
    /* Implicit truncation */
    double price = 9.99;
    int truncatedPrice = price;          // truncated to 9, no warning
    printf("Truncation: %.2f -> %d\n", price, truncatedPrice);

    /* Explicit cast — shows intent */
    int result = (int)(price * 100);     // 999, not 1000 (due to truncation of 999.0? Actually 9.99*100 = 999.0) 

    /* Integer promotion */
    char small = 100;
    char bigger = 200;
    int sum = small + bigger;            // promoted to int, sum = 300
    printf("Promotion: %d + %d = %d\n", small, bigger, sum);

    /* Sign extension when converting signed to unsigned */
    signed char s = -5;
    unsigned int u = (unsigned int)s;    // becomes a large number due to sign extension
    printf("Sign extension: %d -> %u\n", s, u);

    return 0;
}