Variables & Data Types

#include <stdio.h>    /* Include standard I/O so we can use printf */

int main(void) {      /* int main: the function that runs when the program starts */
                      /* void: this main takes no command-line arguments */

    /* --- DECLARATION ONLY (value is garbage until assigned!) --- */
    int age;          /* declares a slot for a whole number called 'age' */
    age = 20;         /* now we store 20 into it */

    /* --- DECLARATION WITH INITIALIZATION (preferred) --- */
    double height = 1.75;   /* decimal number, initialized immediately */
    char   grade  = 'B';    /* a single character — note single quotes */
    int    score  = 95;

    /* --- PRINTING --- */
    printf("Age:    %d\n",   age);     /* %d = print an integer */
    printf("Height: %f\n",   height);  /* %f = print a double */
    printf("Grade:  %c\n",   grade);   /* %c = print a character */
    printf("Score:  %d\n",   score);

    /* --- REASSIGNMENT --- */
    score = 100;      /* store a new value — old value (95) is gone forever */
    printf("New score: %d\n", score);

    /* --- sizeof --- */
    printf("int is %zu bytes\n",    sizeof(int));    /* 4 */
    printf("double is %zu bytes\n", sizeof(double)); /* 8 */
    printf("char is %zu bytes\n",   sizeof(char));   /* 1 */

    return 0;   /* 0 means the program ran successfully */
}

#include <stdio.h>
#include <stdint.h>   /* For portable exact-width types: int32_t, uint8_t, etc. */

int main(void) {

    /* --- SIGNED vs UNSIGNED --- */
    int   signed_num   = -42;          /* can hold negative numbers */
    unsigned int pos   = 4294967295u;  /* u suffix = unsigned literal */

    printf("Signed:   %d\n",  signed_num);
    printf("Unsigned: %u\n",  pos);    /* %u = unsigned int format */

    /* --- OVERFLOW DEMO (signed vs unsigned wrap) --- */
    /* What happens when unsigned goes below 0? It wraps around! */
    unsigned int wrap = 0;
    wrap = wrap - 1;   /* subtracting 1 from 0 wraps to 4294967295 */
    printf("0 - 1 (unsigned): %u\n", wrap);  /* prints 4294967295 */

    /* --- PORTABLE EXACT-WIDTH TYPES --- */
    int32_t  a = 2147483647;  /* exactly 32 bits, signed — always! */
    uint8_t  b = 255;         /* exactly 8 bits, unsigned (0..255) */
    int64_t  c = 9000000000LL;/* exactly 64 bits — note the LL suffix for large literals */

    printf("int32_t max: %d\n",    a);
    printf("uint8_t max: %hhu\n",  b);  /* %hhu = unsigned char format */
    printf("int64_t big: %lld\n",  c);  /* %lld = long long format */

    return 0;
}

#include <stdio.h>

int main(void) {
    int a = 255;        /* decimal   */
    int b = 0xFF;       /* hex       */
    int c = 0377;       /* octal     */
    int d = 0b11111111; /* binary (GCC extension) */

    /* All four variables hold the same value: 255 */
    printf("%d %d %d %d\n", a, b, c, d);   /* 255 255 255 255 */

    /* printf can print in different bases too */
    printf("hex: %x  octal: %o  decimal: %d\n", a, a, a);
    /* hex: ff  octal: 377  decimal: 255 */

    /* The octal gotcha */
    int x = 010;   /* THIS IS 8, NOT 10 */
    printf("010 in decimal is: %d\n", x);  /* prints 8 */

    return 0;
}

#include <stdio.h>
#include <math.h>   /* for fabs() — compile with -lm */

int main(void) {
    double a = 0.1;
    double b = 0.2;
    double c = 0.3;

    /* BAD: never compare floats with == */
    if (a + b == c) {
        printf("equal\n");       /* this line is NEVER reached */
    } else {
        printf("not equal\n");   /* this prints instead — floating point surprise! */
    }

    /* Print the actual stored values to see why */
    printf("0.1 + 0.2 = %.17f\n", a + b);  /* 0.30000000000000004 */
    printf("0.3       = %.17f\n", c);       /* 0.29999999999999999 */

    /* CORRECT: use an epsilon (tolerance) comparison */
    if (fabs((a + b) - c) < 1e-9) {
        printf("close enough — treated as equal\n");
    }

    return 0;
}