Enum, Typedef & Preprocessor

What is an enum?

An enumeration is a user-defined type whose values are a fixed list of named integer constants. It replaces magic numbers with readable names.

enum Color { RED, GREEN, BLUE };   /* 0, 1, 2 */

enum Color c = GREEN;
printf("%d\n", c);              /* prints 1 */

Numbering rules:

enum A { X, Y, Z };              /* 0, 1, 2            */
enum B { P = 5, Q, R };          /* 5, 6, 7            */
enum C { M = 1, N = 10, O };    /* 1, 10, 11          */
enum D { S = 2, T = 2 };        /* duplicates allowed */

Enum use — why and where

• Readable constants — if (s == ERROR) beats if (s == 3)
• Automatic numbering — add a member without renumbering by hand
• Grouping — related values live together as one named type
• Switch statements — the compiler can warn about unhandled members
• State machines — states get names instead of numbers
• Flags — with explicit powers of two you can OR them together
• Debugger friendly — unlike a macro, an enum is a real symbol

/* State machine with a switch */
enum State { IDLE, RUNNING, PAUSED, STOPPED };

enum State s = RUNNING;

switch (s) {
    case IDLE:    puts("idle");    break;
    case RUNNING: puts("running"); break;
    case PAUSED:  puts("paused");  break;
    case STOPPED: puts("stopped"); break;
}

/* Flags — explicit powers of two can be combined */
enum Perm { READ = 1, WRITE = 2, EXEC = 4 };

int p = READ | WRITE;
if (p & WRITE) puts("writable");

/* Printing enum names — parallel string array */
enum Day { MON, TUE, WED, COUNT };

const char *names[] = { "Mon", "Tue", "Wed" };

for (int i = MON; i < COUNT; i++)
    printf("%d = %s\n", i, names[i]);

Typedef use

typedef gives an existing type a new name. It creates an alias, not a new type.

typedef unsigned long ulong;
ulong count = 0;

/* Structures — no need to repeat 'struct' */
typedef struct {
    char name[50];
    int  roll;
} Student;

Student s;                 /* instead of struct Student s; */

/* Enums */
typedef enum { FALSE, TRUE } Bool;
Bool done = FALSE;

/* Pointer types */
typedef char *String;
String msg = "hello";

/* Function pointers — the biggest readability win */
typedef int (*Compare)(const void *, const void *);
Compare cmp = myCompare;

/* Arrays */
typedef int Matrix[3][3];
Matrix m;                 /* int m[3][3]; */

Why use it:

• Readability — the declaration describes the problem, not the plumbing
• Shorter code — drop the repeated struct and enum keywords
• Portability — change one typedef to switch int to long everywhere
• Complex declarations — function pointers and arrays become readable names
• Self-documenting — typedef int Celsius; states the unit

Introduction to the preprocessor

The preprocessor is a text-processing step that runs before compilation. It obeys lines beginning with # and produces an expanded source file called a translation unit.

Macro definitions

Object-like macros — symbolic constants:

#define PI      3.14159
#define MAX     100
#define GREET   "Hello"

int a[MAX];                 /* becomes int a[100]; */

Function-like macros — with parameters:

#define SQUARE(x)   ((x) * (x))
#define MAX2(a, b)  (((a) > (b)) ? (a) : (b))

printf("%d\n", SQUARE(2 + 3));   /* 25 — parentheses saved us */

/* Why the parentheses matter */
#define BAD(x)  x * x

BAD(2 + 3)   /* expands to 2 + 3 * 2 + 3  = 11, not 25 */

Multi-statement macros — the do while (0) idiom:

#define SWAP(a, b) do {        \
    int tmp = (a);              \
    (a) = (b);                   \
    (b) = tmp;                   \
} while (0)

SWAP(x, y);   /* behaves like one statement */

Undefining — #undef:

#define SIZE 10
int a[SIZE];

#undef SIZE          /* SIZE no longer defined */
#define SIZE 20       /* safe to redefine now  */

Macros vs functions:

Predefined macros:

File inclusion

#include copies the entire contents of a file into the current source at that point.

#include <stdio.h>     /* system header  — search system paths  */
#include "myutils.h"   /* your header    — search here first    */

Header guards — stop a header being pasted twice:

/* myutils.h */
#ifndef MYUTILS_H
#define MYUTILS_H

int add(int a, int b);
int sub(int a, int b);

#endif /* MYUTILS_H */

The first inclusion defines MYUTILS_H; the second finds it already defined and skips everything to #endif.

Circular inclusion:

/* a.h includes b.h, and b.h includes a.h → infinite loop */
/* Fixes:                                                 */
/*   1. Put an include guard in EVERY header              */
/*   2. Use forward declarations instead of #include      */
/*   3. Include headers in the .c file, not the .h file   */

Conditional compilation

#define LEVEL 2

#if LEVEL == 1
    puts("basic");
#elif LEVEL == 2
    puts("standard");
#else
    puts("advanced");
#endif

#ifdef DEBUG                /* is DEBUG defined?     */
    printf("debug build\n");
#endif

#ifndef MAX                /* is MAX NOT defined?   */
    #define MAX 100          /* provide a default     */
#endif

#if defined(LINUX) || defined(MAC)
    puts("unix-like");
#endif

Where it is used:

• Debug builds — tracing that disappears in release
• Cross-platform code — different code per operating system
• Feature toggles — ship one code base with optional features
• Include guards — the #ifndef pattern
• Commenting out code — #if 0 … #endif nests safely, unlike /* */

Error, warning, line, and pragma directives

#error — stop the build deliberately:

#ifndef CONFIG_H
    #error "config.h must be included first"
#endif

#if __STDC_VERSION__ < 199901L
    #error "This code requires C99 or later"
#endif

#warning — a message without failing (a common extension):

#ifdef USE_OLD_API
    #warning "USE_OLD_API is deprecated"
#endif

#line — override the reported line number and file name:

#line 100                    /* next line is treated as line 100 */
#line 50 "generated.c"     /* also change __FILE__            */

printf("%s:%d\n", __FILE__, __LINE__);

Its real use is in code generators such as lex and yacc, so that error messages point at the original input file rather than the generated C.

#pragma — compiler-specific instructions:

Preprocessor operators — #, ##, and defined()

Stringizing with #:

#define STR(x)  #x

printf("%s\n", STR(hello));      /* prints hello */

/* Print a variable's NAME and value */
#define SHOW(v)  printf(#v " = %d\n", (v))

int count = 42;
SHOW(count);                    /* count = 42 */

Token pasting with ##:

#define CAT(a, b)  a##b

int var1 = 10, var2 = 20;
printf("%d\n", CAT(var, 1));   /* becomes var1 → 10 */

/* Generating similar function names */
#define MAKE_GETTER(type, name)      \
    type get_##name(void) { return name; }

The two-level stringize trick:

#define STR(x)   #x
#define XSTR(x)  STR(x)

#define VERSION 3

STR(VERSION)    /* "VERSION" — the name  */
XSTR(VERSION)   /* "3"       — the value */

Variadic macros, include guards, and platform detection

Variadic macros — ... and __VA_ARGS__:

#define LOG(fmt, ...)  \
    fprintf(stderr, "[%s:%d] " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)

LOG("value = %d", x);
/* [main.c:42] value = 10 */

/* Handling an EMPTY argument list */
/* GNU extension:   ##__VA_ARGS__  removes the stray comma */
#define LOG2(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)

/* C23 standard way: __VA_OPT__(,) */
#define LOG3(fmt, ...) fprintf(stderr, fmt __VA_OPT__(,) __VA_ARGS__)

Include guards — two styles:

Debug builds:

#ifdef DEBUG
    #define TRACE(...) fprintf(stderr, __VA_ARGS__)
#else
    #define TRACE(...) /* nothing at all */
#endif

TRACE("x = %d\n", x);   /* compile with -DDEBUG to enable */

Platform and compiler detection:

#if defined(_WIN32)
    #define PLATFORM "Windows"
#elif defined(__linux__)
    #define PLATFORM "Linux"
#elif defined(__APPLE__)
    #define PLATFORM "macOS"
#else
    #define PLATFORM "Unknown"
#endif

#if defined(__GNUC__)
    #define COMPILER "GCC"
#elif defined(_MSC_VER)
    #define COMPILER "MSVC"
#elif defined(__clang__)
    #define COMPILER "Clang"
#endif

How expansion actually works

• The preprocessor rescans the replacement text and expands macros found there
• Arguments are expanded before substitution, unless used with # or ##
• That exception is exactly why the two-level XSTR trick is needed
• Expansion stops when no macro names remain

#define A  B
#define B  10

A   /* A → B → 10 : rescanning keeps going */

/* See the result yourself */
/*   gcc -E  file.c            full expansion   */
/*   gcc -dM -E file.c         every macro       */

Why macros are not recursive

While a macro is being expanded, its own name is marked as unavailable — often called "blue painting". The inner occurrence is left as ordinary text.

#define A  A + 1

A    /* expands ONCE to  A + 1  and stops */

#define F(x)  F(x) + 1

F(2)  /* becomes F(2) + 1 — the inner F is untouched */

• This is a deliberate rule that guarantees preprocessing terminates
• Bounded "recursion" is possible by defining several numbered macros, but it is unreadable
• If you need real recursion, write a function — that is what they are for

The multiple evaluation trap

#define MAX(a, b)  (((a) > (b)) ? (a) : (b))

int i = 5, j = 3;
int m = MAX(i++, j);

/* Expands to:  ((i++) > (j)) ? (i++) : (j)   */
/* i is incremented TWICE — a real bug        */

• Never pass an expression with side effects to a macro
• Prefer an inline function — arguments are evaluated exactly once
• Watch out for i++, ++i, and function calls in macro arguments

/* Safe alternative */
static inline int maxInt(int a, int b) {
    return (a > b) ? a : b;
}

Debugging, assertions, and NDEBUG

#include <assert.h>

assert(n > 0);   /* aborts with file and line if false */

/* Compiling with -DNDEBUG removes every assert entirely */

/* Levelled tracing, all removed in release builds */
#ifdef DEBUG
    #define DBG(...)   do {                                     \
        fprintf(stderr, "%s:%d:%s: ",                        \
                __FILE__, __LINE__, __func__);                \
        fprintf(stderr, __VA_ARGS__);                        \
    } while (0)
#else
    #define DBG(...)   ((void)0)
#endif

X-macros — one list, many uses

An X-macro keeps an enum and its name table in sync automatically, removing the classic bug where you add an enum member but forget the string.

/* The single source of truth */
#define COLOR_LIST  \
    X(RED)           \
    X(GREEN)         \
    X(BLUE)

/* Use 1 — build the enum */
#define X(name)  name,
enum Color { COLOR_LIST COLOR_COUNT };
#undef X

/* Use 2 — build the matching name table */
#define X(name)  #name,
const char *colorName[] = { COLOR_LIST };
#undef X

printf("%s\n", colorName[GREEN]);   /* GREEN */

Designing a header file

/* mathutils.h */
#ifndef MATHUTILS_H
#define MATHUTILS_H

#include <stddef.h>      /* only what the header itself needs */

#define MU_PI 3.14159265358979

typedef struct { double x, y; } MuPoint;

double mu_distance(MuPoint a, MuPoint b);
double mu_area(double r);

#endif /* MATHUTILS_H */

• Guard everything — a guard in every header, named after the path
• Declarations only — definitions belong in the .c file
• Prefix public names — mu_ here, to avoid collisions
• Include minimally — every extra #include spreads to all users
• Never put static variable definitions in a header

Common mistakes