Typedef and Enum in C — Beware the 11th State

#include <stdio.h>

/* Create a friendlier alias for 'unsigned char'.
   On most platforms this is an 8-bit value (0-255).
   Now our intent is crystal clear: this holds a byte. */
typedef unsigned char byte;

/* Create an alias for 'unsigned long int'.
   This is common in cross-platform code so you can swap
   the underlying type in ONE place if the platform changes. */
typedef unsigned long int uint32;

/* A simple alias for a pointer-to-char (a string in C). */
typedef char* string;

int main(void) {
    /* Declare variables using our new type names.
       The compiler sees 'byte' and treats it as 'unsigned char'. */
    byte sensorReading = 200;      /* holds a raw byte from a sensor */
    uint32 totalPackets = 1000000; /* a large counter */
    string playerName = "Alice";   /* pointer to a string literal */

    printf("Sensor reading : %u\n",  sensorReading);
    printf("Total packets  : %lu\n", totalPackets);
    printf("Player name    : %s\n",  playerName);

    /* sizeof still works perfectly — typedef is just a nickname,
       not a new data type in memory. */
    printf("Size of byte   : %zu bytes\n", sizeof(byte));   /* same as unsigned char */
    printf("Size of uint32 : %zu bytes\n", sizeof(uint32)); /* same as unsigned long int */

    return 0;
}

#include <stdio.h>

/* Define an enum for the four compass directions.
   The compiler assigns: NORTH=0, SOUTH=1, EAST=2, WEST=3
   automatically, counting from zero. */
enum CompassDirection {
    NORTH,   /* 0 */
    SOUTH,   /* 1 */
    EAST,    /* 2 */
    WEST     /* 3 */
};

/* Define an enum for HTTP-style status codes.
   Here we override the default values to match real HTTP codes.
   This is common when your enum must match an external protocol. */
enum HttpStatus {
    HTTP_OK            = 200,
    HTTP_NOT_FOUND     = 404,
    HTTP_SERVER_ERROR  = 500
};

/* A helper that translates a CompassDirection into a readable string. */
const char* directionToString(enum CompassDirection dir) {
    switch (dir) {
        case NORTH: return "North";
        case SOUTH: return "South";
        case EAST:  return "East";
        case WEST:  return "West";
        default:    return "Unknown";  /* defensive: handle bad values */
    }
}

int main(void) {
    /* Declare a variable of our enum type. */
    enum CompassDirection playerFacing = NORTH;

    printf("Player is facing : %s\n", directionToString(playerFacing));
    printf("Numeric value    : %d\n", playerFacing); /* prints 0 */

    /* Change direction — only valid enum values feel natural here. */
    playerFacing = EAST;
    printf("Player turned    : %s\n", directionToString(playerFacing));
    printf("Numeric value    : %d\n", playerFacing); /* prints 2 */

    /* Custom HTTP status codes in action. */
    enum HttpStatus serverResponse = HTTP_NOT_FOUND;
    printf("\nServer responded with code: %d\n", serverResponse);

    if (serverResponse == HTTP_NOT_FOUND) {
        printf("Resource was not found on the server.\n");
    }

    return 0;
}

#include <stdio.h>

/* BEFORE: the verbose way — you must write 'enum TrafficLight' every time.
   enum TrafficLight { RED, YELLOW, GREEN };
   enum TrafficLight signal = RED;           <-- repetitive and noisy
*/

/* AFTER: typedef + enum together.
   Now 'TrafficLight' alone is a complete, valid type name. */
typedef enum TrafficLight {
    RED,     /* 0 — stop  */
    YELLOW,  /* 1 — caution */
    GREEN    /* 2 — go    */
} TrafficLight;

/* A real function that acts on our custom type.
   The parameter type reads like English: 'TrafficLight signal' */
void printSignalInstruction(TrafficLight signal) {
    switch (signal) {
        case RED:
            printf("Signal: RED    -> Stop the vehicle.\n");
            break;
        case YELLOW:
            printf("Signal: YELLOW -> Prepare to stop.\n");
            break;
        case GREEN:
            printf("Signal: GREEN  -> Proceed safely.\n");
            break;
        default:
            printf("Signal: UNKNOWN -> Signal malfunction!\n");
            break;
    }
}

/* Simulates cycling through a traffic light sequence. */
int main(void) {
    /* Declare using the clean typedef name — no 'enum' keyword needed. */
    TrafficLight currentSignal;

    printf("--- Traffic Light Sequence ---\n");

    /* Cycle through each phase */
    currentSignal = RED;
    printSignalInstruction(currentSignal);

    currentSignal = GREEN;
    printSignalInstruction(currentSignal);

    currentSignal = YELLOW;
    printSignalInstruction(currentSignal);

    currentSignal = RED;  /* back to stop */
    printSignalInstruction(currentSignal);

    /* Demonstrate that enum values are integers under the hood */
    printf("\nRED=%d  YELLOW=%d  GREEN=%d\n", RED, YELLOW, GREEN);

    return 0;
}

#include <stdio.h>

/* ── Types ─────────────────────────────────────────────── */

/* typedef for a simple score value — portable and self-documenting */
typedef unsigned int Score;

/* typedef + enum for character state — clean and unambiguous */
typedef enum CharacterState {
    STATE_IDLE,     /* 0: standing still, waiting for input */
    STATE_RUNNING,  /* 1: moving across the map */
    STATE_JUMPING,  /* 2: in the air */
    STATE_DEAD      /* 3: health reached zero */
} CharacterState;

/* ── Helper Functions ───────────────────────────────────── */

/* Converts a state enum to a human-readable label for display */
const char* stateToLabel(CharacterState state) {
    switch (state) {
        case STATE_IDLE:    return "Idle";
        case STATE_RUNNING: return "Running";
        case STATE_JUMPING: return "Jumping";
        case STATE_DEAD:    return "Dead";
        default:            return "Corrupted";
    }
}

/* Decides if a state transition is legal.
   You can't jump if you're dead, for example. */
int canTransition(CharacterState from, CharacterState to) {
    /* Dead characters can't do anything */
    if (from == STATE_DEAD) {
        return 0; /* 0 = false */
    }
    /* Can't jump while already jumping */
    if (from == STATE_JUMPING && to == STATE_JUMPING) {
        return 0;
    }
    return 1; /* 1 = true */
}

/* Attempts a state change and reports what happened */
void applyTransition(CharacterState* current, CharacterState next) {
    if (canTransition(*current, next)) {
        printf("  Transition: %-10s -> %s\n",
               stateToLabel(*current), stateToLabel(next));
        *current = next;  /* update the state through the pointer */
    } else {
        printf("  BLOCKED:    Cannot move from %s to %s\n",
               stateToLabel(*current), stateToLabel(next));
    }
}

/* ── Main ───────────────────────────────────────────────── */

int main(void) {
    CharacterState heroState = STATE_IDLE; /* hero starts idle */
    Score heroScore = 0;                   /* Score alias in action */

    printf("=== Game Character State Machine ===\n\n");
    printf("Initial state : %s\n\n", stateToLabel(heroState));

    /* Simulate a sequence of in-game events */
    applyTransition(&heroState, STATE_RUNNING); /* player presses move */
    applyTransition(&heroState, STATE_JUMPING); /* player presses jump */
    applyTransition(&heroState, STATE_JUMPING); /* double-jump: blocked */
    applyTransition(&heroState, STATE_RUNNING); /* lands back down */
    applyTransition(&heroState, STATE_DEAD);    /* enemy hit */
    applyTransition(&heroState, STATE_RUNNING); /* blocked: already dead */

    heroScore = 3200; /* would normally accumulate during play */

    printf("\nFinal state   : %s\n", stateToLabel(heroState));
    printf("Final score   : %u\n",  heroScore);

    return 0;
}

#include <stdio.h>

/* ── Typedef for a struct — no more 'struct' keyword ── */
typedef struct {
    int x;
    int y;
} Point;

/* ── Typedef for a function pointer — clean API ── */
typedef int (*Comparator)(int a, int b);

/* ── Sample comparator functions ── */
int ascending(int a, int b)  { return a - b; }
int descending(int a, int b) { return b - a; }

/* ── A sort function that takes a comparator ── */
void bubbleSort(int arr[], int n, Comparator cmp) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (cmp(arr[j], arr[j + 1]) > 0) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    /* Use Point without 'struct' keyword */
    Point p1 = {10, 20};
    printf("Point: (%d, %d)\n", p1.x, p1.y);

    /* Use Comparator alias to choose sorting order at runtime */
    int values[] = {3, 1, 4, 1, 5, 9, 2, 6};
    int n = sizeof(values) / sizeof(values[0]);

    printf("Original: ");
    for (int i = 0; i < n; i++) printf("%d ", values[i]);
    printf("\n");

    bubbleSort(values, n, ascending);
    printf("Ascending: ");
    for (int i = 0; i < n; i++) printf("%d ", values[i]);
    printf("\n");

    bubbleSort(values, n, descending);
    printf("Descending: ");
    for (int i = 0; i < n; i++) printf("%d ", values[i]);
    printf("\n");

    return 0;
}