Typedef and Enum in C — Beware the 11th State

#include <stdio.h>

/* Create a friendlier alias for 'unsigned char'.
   On all conforming platforms this is exactly 1 byte (0-255).
   Our intent is crystal clear: this holds a raw byte. */
typedef unsigned char byte;

/* For a guaranteed 32-bit unsigned integer, prefer stdint.h.
   Using 'unsigned long int' directly is platform-dependent:
   it is 4 bytes on Windows (LLP64) and 8 bytes on Linux 64-bit (LP64).
   FIX: replaced unsigned long int with uint32_t to guarantee 4 bytes
   and added the stdint.h include. */
#include <stdint.h>
typedef uint32_t uint32;

/* A pointer alias for illustration only.
   WARNING: pointer typedefs hide the asterisk.
   'string a = "hello", b;' leaves b as an uninitialised char*,
   not a second string. Most production codebases avoid this pattern. */
typedef char* string;

int main(void) {
    byte sensorReading = 200;      /* holds a raw byte from a sensor */
    uint32 totalPackets = 1000000; /* guaranteed 32-bit counter */
    string playerName = "Alice";   /* pointer to a string literal */

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

    /* sizeof returns the size of the original type.
       byte  -> 1 byte on all platforms.
       uint32 -> 4 bytes on all platforms (guaranteed by stdint.h). */
    printf("Size of byte   : %zu bytes\n", sizeof(byte));
    printf("Size of uint32 : %zu bytes\n", sizeof(uint32));

    return 0;
}

#include <stdio.h>

/* Named enum for compass directions.
   Compiler assigns: NORTH=0, SOUTH=1, EAST=2, WEST=3 */
enum CompassDirection {
    NORTH,
    SOUTH,
    EAST,
    WEST
};

/* Enum with explicit values matching real HTTP status codes.
   Common when the enum must interface with an external protocol. */
enum HttpStatus {
    HTTP_OK           = 200,
    HTTP_NOT_FOUND    = 404,
    HTTP_SERVER_ERROR = 500
};

/* Anonymous enum used as compile-time integer constants.
   Scoped and debugger-visible — preferred over #define for integers. */
enum {
    MAX_RETRIES  = 5,
    BUFFER_SIZE  = 256
};

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: handles invalid integers */
    }
}

int main(void) {
    enum CompassDirection playerFacing = NORTH;

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

    playerFacing = EAST;
    printf("Player turned    : %s\n", directionToString(playerFacing));
    printf("Numeric value    : %d\n", playerFacing);

    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");
    }

    printf("\nMax retries : %d\n", MAX_RETRIES);
    printf("Buffer size : %d\n", BUFFER_SIZE);

    return 0;
}

#include <stdio.h>

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

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

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 — fail safe.\n");
            break;
    }
}

int main(void) {
    TrafficLight currentSignal;

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

    currentSignal = RED;
    printSignalInstruction(currentSignal);

    currentSignal = GREEN;
    printSignalInstruction(currentSignal);

    currentSignal = YELLOW;
    printSignalInstruction(currentSignal);

    currentSignal = RED;
    printSignalInstruction(currentSignal);

    printf("\nRED=%d  YELLOW=%d  GREEN=%d\n", RED, YELLOW, GREEN);

    return 0;
}

#include <stdio.h>
#include <stdint.h> /* for uint32_t */

/* typedef for a score value — fixed width and self-documenting */
typedef uint32_t Score;

/* typedef + enum for character state */
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;

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"; /* invalid integer guard */
    }
}

/* Returns 1 (true) if the transition is legal, 0 (false) otherwise.
   On C99+ you can replace int with _Bool and include <stdbool.h>.
   int is used here for maximum portability to C89 embedded toolchains. */
int canTransition(CharacterState from, CharacterState to) {
    if (from == STATE_DEAD)                          return 0;
    if (from == STATE_JUMPING && to == STATE_JUMPING) return 0;
    return 1;
}

void applyTransition(CharacterState* current, CharacterState next) {
    if (canTransition(*current, next)) {
        printf("  Transition: %-10s -> %s\n",
               stateToLabel(*current), stateToLabel(next));
        *current = next;
    } else {
        printf("  BLOCKED:    Cannot move from %s to %s\n",
               stateToLabel(*current), stateToLabel(next));
    }
}

int main(void) {
    CharacterState heroState = STATE_IDLE;
    Score heroScore = 0;

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

    applyTransition(&heroState, STATE_RUNNING);
    applyTransition(&heroState, STATE_JUMPING);
    applyTransition(&heroState, STATE_JUMPING); /* double-jump: blocked */
    applyTransition(&heroState, STATE_RUNNING);
    applyTransition(&heroState, STATE_DEAD);
    applyTransition(&heroState, STATE_RUNNING); /* dead: blocked */

    heroScore = 3200;

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

    return 0;
}

#include <stdio.h>

/* typedef for a struct — no 'struct' keyword needed at declaration */
typedef struct {
    int x;
    int y;
} Point;

/* typedef for a function pointer — clean, self-documenting callback type */
typedef int (*Comparator)(int a, int b);

/* FIX: subtraction-based comparators (return a - b) overflow for extreme
   integer values. The portable idiom below is safe for all int inputs. */
int ascending(int a, int b)  { return (a > b) - (a < b); }
int descending(int a, int b) { return (b > a) - (b < a); }

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) {
    Point p1 = {10, 20};
    printf("Point: (%d, %d)\n", p1.x, p1.y);

    int values[] = {3, 1, 4, 1, 5, 9, 2, 6};
    int n = (int)(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;
}

#include <stdio.h>

typedef enum {
    NORTH,
    EAST,
    SOUTH,
    WEST
} Direction;

/* FIX: added DIRECTION_MAX sentinel as a clean upper-bound for validation.
   Place it last so it always equals the count of valid values. */
enum { DIRECTION_MAX = WEST };

/* Runtime guard — validate any integer before treating it as a Direction.
   This is your only safety net in standard C. */
int isValidDirection(int raw) {
    return raw >= NORTH && raw <= DIRECTION_MAX;
}

int main(void) {
    /* This compiles without error or warning by default.
       Enable -Wconversion to get a warning on implicit enum casts. */
    int rawInput = 99; /* simulates a value arriving from a sensor or packet */

    if (!isValidDirection(rawInput)) {
        fprintf(stderr, "Invalid direction received: %d\n", rawInput);
        return 1;
    }

    Direction dir = (Direction)rawInput;
    printf("Direction is valid: %d\n", dir);
    return 0;
}

#include <stdio.h>

/* FIX: corrected main() to main(void) throughout patched sections.
   In C, int main() means unspecified parameters, not no parameters.
   int main(void) is the correct idiomatic form. */

typedef enum {
    LOGIN    = 1,
    LOGOUT   = 2,
    PING     = 3,
    /* Values 4-99 are intentionally reserved for future use.
       New packet types must be appended here, never inserted above SHUTDOWN.
       Changing any existing value breaks all stored/serialized data. */
    SHUTDOWN = 100
} PacketType;

/* Sentinel for validation — equals the highest defined value.
   Update this whenever a new PacketType is added. */
enum { PACKET_TYPE_MAX = 100 };

const char* packetName(PacketType t) {
    switch (t) {
        case LOGIN:    return "LOGIN";
        case LOGOUT:   return "LOGOUT";
        case PING:     return "PING";
        case SHUTDOWN: return "SHUTDOWN";
        default:       return "UNKNOWN";
    }
}

/* Validate a raw integer before casting to PacketType.
   Checks both the range and that the value is a defined constant. */
int isValidPacketType(int raw) {
    return (raw == LOGIN || raw == LOGOUT ||
            raw == PING  || raw == SHUTDOWN);
}

int main(void) {
    int stored = 2; /* simulates reading an integer from a database or packet */

    if (!isValidPacketType(stored)) {
        fprintf(stderr, "Unknown packet type: %d\n", stored);
        return 1;
    }

    PacketType pt = (PacketType)stored;
    printf("Packet: %s\n", packetName(pt));
    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <assert.h> /* for static_assert — requires C11 */

/* FIX: corrected main() to main(void). */

typedef enum {
    RED,
    GREEN,
    BLUE
} Color;

/* FIX: static_assert requires C11 and assert.h.
   On C99, use the manual macro below instead.

   C99 fallback:
   #define STATIC_ASSERT(cond, msg) typedef char static_assert_##msg[(cond) ? 1 : -1]
   STATIC_ASSERT(sizeof(Color) == 4, unexpected_color_size);
*/
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
static_assert(sizeof(Color) == 4,
    "Unexpected Color enum size — check compiler flags such as -fshort-enums");
#endif

/* For a binary protocol field, use a fixed-width integer, not an enum type.
   This guarantees the size regardless of compiler flags or platform. */
typedef uint8_t SafeColor;
enum { SAFE_RED = 0, SAFE_GREEN = 1, SAFE_BLUE = 2 };

/* Struct using enum — size is compiler-dependent.
   On GCC x86-64 (default flags): Color is 4 bytes, total is 8 bytes.
   On GCC ARM with -fshort-enums: Color is 1 byte, total may be 6 bytes.
   Never use this layout across a binary boundary without verification. */
typedef struct {
    Color    c;
    uint8_t  pad;
    uint32_t value;
} Packet;

/* Struct using fixed-width integer — size is guaranteed on all platforms. */
typedef struct {
    SafeColor c;      /* always 1 byte */
    uint8_t   pad;    /* always 1 byte */
    uint32_t  value;  /* always 4 bytes */
} SafePacket;

int main(void) {
    printf("sizeof(Color)      : %zu bytes\n", sizeof(Color));
    printf("sizeof(Packet)     : %zu bytes  (compiler-dependent)\n",
           sizeof(Packet));
    printf("sizeof(SafeColor)  : %zu bytes\n", sizeof(SafeColor));
    printf("sizeof(SafePacket) : %zu bytes  (guaranteed)\n",
           sizeof(SafePacket));
    return 0;
}