Keywords in C

01What are Keywords?

Definition

Keywords (also called reserved words) are predefined words in C that have special meanings. They are part of C's syntax and cannot be used as identifiers (variable names, function names, etc.).

Invalid

main.c

int int = 5;     // ERROR!
float return;    // ERROR!
char if = 'a';   // ERROR!

✓Valid

main.c

int number = 5;     // OK
float result;       // OK
char initial = 'a'; // OK

Key Points

• C has 32 keywords (C89/C90 standard)
• All keywords are in lowercase
• Keywords are case-sensitive (if ≠ IF)
• Cannot be used as variable/function names

02All 32 Keywords in C

Complete List of C Keywords (32 Total)

auto

break

case

char

const

continue

default

double

else

enum

extern

float

for

goto

int

long

return

short

signed

sizeof

static

struct

switch

typedef

union

unsigned

void

volatile

while

Note: Newer C Standards Added More

C99: inline, restrict, _Bool, _Complex, _Imaginary
C11: _Alignas, _Alignof, _Atomic, _Generic, _Noreturn, _Static_assert, _Thread_local
C23: true, false, nullptr, constexpr, typeof, static_assert, thread_local, alignas, alignof, bool

02bC99 Keywords (5 New)

The C99 standard (1999) introduced these new keywords:

Keyword	Purpose	Detailed Explanation
inline	Inline function hint	Suggests to the compiler to insert the function code directly at call site for better performance. Reduces function call overhead.
restrict	Pointer aliasing hint	Tells compiler that a pointer is the only way to access the object it points to. Enables aggressive optimizations.
_Bool	Boolean type	Native boolean type that can hold 0 (false) or 1 (true). Use <stdbool.h> for bool, true, false macros.
_Complex	Complex numbers	For complex number arithmetic. Use float _Complex, double _Complex. Include <complex.h> for complex macro.
_Imaginary	Imaginary numbers	For pure imaginary number types. Rarely implemented by compilers. Optional in C99.

c99_keywords.c

1#include <stdio.h>
2#include <stdbool.h>    // For bool, true, false
3#include <complex.h>    // For complex numbers
4
5// inline function - compiler may insert code directly
6inline int square(int x) {
7    return x * x;
8}
9
10// restrict - promise this is the only pointer to this memory
11void copy_array(int *restrict dest, const int *restrict src, int n) {
12    for (int i = 0; i < n; i++) {
13        dest[i] = src[i];
14    }
15}
16
17int main() {
18    // _Bool / bool usage
19    _Bool flag1 = 1;        // Raw C99 boolean
20    bool flag2 = true;      // With stdbool.h (preferred)
21    
22    printf("flag1: %d, flag2: %d\n", flag1, flag2);
23    printf("square(5): %d\n", square(5));
24    
25    // Complex numbers
26    double _Complex z = 3.0 + 4.0 * I;
27    printf("Complex: %.1f + %.1fi\n", creal(z), cimag(z));
28    
29    return 0;
30}

02cC11 Keywords (7 New)

The C11 standard (2011) added powerful new features:

Keyword	Macro Form	Detailed Explanation
_Alignas	alignas	Specifies memory alignment for a variable. _Alignas(16) int x; aligns x to 16-byte boundary.
_Alignof	alignof	Returns the alignment requirement of a type. Like sizeof but for alignment.
_Atomic	atomic_*	Declares atomic variables for lock-free thread-safe operations. Essential for multi-threaded programs.
_Generic	-	Type-generic selection. Enables function overloading by selecting code based on expression type at compile time.
_Noreturn	noreturn	Marks functions that never return (like exit(), abort()). Helps compiler optimize.
_Static_assert	static_assert	Compile-time assertion. Causes compilation error if condition is false. Great for catching errors early.
_Thread_local	thread_local	Each thread gets its own copy of the variable. Essential for thread-safe global state.

c11_keywords.c

1#include <stdio.h>
2#include <stdalign.h>   // For alignas, alignof
3#include <stdnoreturn.h> // For noreturn
4#include <stdatomic.h>  // For atomic types
5
6// Compile-time assertion
7_Static_assert(sizeof(int) >= 4, "int must be at least 4 bytes");
8
9// Function that never returns
10noreturn void fatal_error(const char *msg) {
11    printf("FATAL: %s\n", msg);
12    exit(1);
13}
14
15// Type-generic macro using _Generic
16#define print_type(x) _Generic((x), \
17    int: "int", \
18    float: "float", \
19    double: "double", \
20    char*: "string", \
21    default: "unknown")
22
23int main() {
24    // Memory alignment
25    alignas(16) int aligned_var = 42;
26    printf("Alignment of int: %zu\n", alignof(int));
27    printf("Alignment of aligned_var: %zu\n", alignof(aligned_var));
28    
29    // Atomic variable for thread safety
30    atomic_int counter = 0;
31    atomic_fetch_add(&counter, 1);  // Thread-safe increment
32    printf("Counter: %d\n", counter);
33    
34    // Type-generic selection
35    printf("Type of 42: %s\n", print_type(42));
36    printf("Type of 3.14: %s\n", print_type(3.14));
37    
38    // Thread-local (each thread has own copy)
39    _Thread_local static int per_thread_counter = 0;
40    per_thread_counter++;
41    
42    return 0;
43}

_Generic is Powerful!

_Generic enables "function overloading" in C by selecting different code paths based on type. The tgmath.h header uses this to make sin(), cos(), etc. work with float, double, and complex types!

02dC23 Keywords (Latest Standard) 🆕

The C23 standard (2023/2024) brings major improvements and new keywords:

Keyword	Status	Detailed Explanation
true	Now a keyword!	No longer a macro - true is a proper keyword. Value is 1.
false	Now a keyword!	No longer a macro - false is a proper keyword. Value is 0.
bool	Now a keyword!	Boolean type is now a native keyword. No need for <stdbool.h> anymore.
nullptr	New!	Type-safe null pointer constant. Better than NULL macro. Has type nullptr_t.
constexpr	New!	Compile-time constant expressions. Like const but evaluated at compile time. From C++!
typeof	Standardized!	Gets the type of an expression. Was a GCC extension, now standard. typeof(x) y; makes y same type as x.
typeof_unqual	New!	Like typeof but removes const/volatile qualifiers. typeof_unqual(const int) → int.
static_assert	Now a keyword!	Was _Static_assert with macro. Now a proper keyword. Message is optional in C23.
alignas	Now a keyword!	Was _Alignas with macro. Now a proper keyword.
alignof	Now a keyword!	Was _Alignof with macro. Now a proper keyword.
thread_local	Now a keyword!	Was _Thread_local with macro. Now a proper keyword.
_BitInt(N)	New!	Arbitrary-width integers! _BitInt(128) creates a 128-bit integer. N can be any positive integer.
_Decimal32/64/128	New!	Decimal floating-point types for precise financial calculations. No binary rounding errors!

c23_keywords.c

1// C23 Features - Use with -std=c23 compiler flag
2#include <stdio.h>
3// No need for <stdbool.h> in C23!
4
5int main() {
6    // bool, true, false are now keywords
7    bool is_valid = true;
8    bool is_empty = false;
9    
10    // nullptr - type-safe null pointer
11    int *ptr = nullptr;  // Better than NULL
12    if (ptr == nullptr) {
13        printf("Pointer is null\n");
14    }
15    
16    // constexpr - compile-time constants
17    constexpr int BUFFER_SIZE = 1024;
18    constexpr double PI = 3.14159265359;
19    
20    // typeof - get type of expression
21    int x = 42;
22    typeof(x) y = 100;  // y is also int
23    typeof(x + 1.0) z = 3.14;  // z is double
24    
25    // typeof_unqual - remove const/volatile
26    const int ci = 10;
27    typeof_unqual(ci) mutable_copy = ci;  // mutable_copy is int, not const int
28    mutable_copy = 20;  // OK, not const!
29    
30    // static_assert - no message required in C23
31    static_assert(sizeof(int) >= 4);  // Message optional!
32    static_assert(BUFFER_SIZE > 0, "Buffer must be positive");
33    
34    // _BitInt - arbitrary width integers
35    _BitInt(128) big_number = 12345678901234567890wb;
36    unsigned _BitInt(256) huge = 0;
37    
38    // Decimal floating point (if supported)
39    // _Decimal64 price = 19.99DD;  // No binary rounding errors!
40    
41    printf("is_valid: %d\n", is_valid);
42    printf("BUFFER_SIZE: %d\n", BUFFER_SIZE);
43    
44    return 0;
45}

✓C23 Simplifications

• No more #include <stdbool.h>
• nullptr replaces NULL
• Cleaner names: alignas vs _Alignas
• Optional message in static_assert

🆕 C23 New Features

• constexpr for compile-time eval
• typeof standardized
• _BitInt(N) arbitrary integers
• Decimal floating-point types

Compiler Support

C23 features require a recent compiler with -std=c23 or -std=c2x flag. GCC 13+, Clang 16+ have partial support. Check your compiler documentation for availability.

03Data Type Keywords

These keywords define the type of data a variable can hold.

int

4 bytes • Whole numbers

main.c

int age = 25;
int count = -10;
int sum = age + count;  // sum = 15

float

4 bytes

main.c

float price = 19.99f;  // f suffix!
float temp = -5.5f;

double

8 bytes • More precise

main.c

double pi = 3.14159265359;
double result = pi * 2;

char

1 byte • Single character

main.c

char grade = 'A';      // Use single quotes!
char newline = '\n';   // Special character
char digit = '5';      // Character, not number 5

void

"No type"

main.c

void sayHello(void) {   // Returns nothing, takes nothing
    printf("Hello!\n");
}
void *ptr;              // Generic pointer (any type)

short

2 bytes • Small range

main.c

short small = 32000;
short year = 2024;

long

4-8 bytes • Large range

main.c

long population = 8000000000L;
long long huge = 9223372036854775807LL;

signed

Negative + Positive

main.c

signed int temp = -10;  // Can be negative
int x = -5;             // signed by default

unsigned

Only 0 and Positive

main.c

unsigned int count = 0;   // 0 to 4 billion
unsigned char byte = 255; // 0 to 255

04Control Flow Keywords

These keywords control the flow of execution in your program.

Decision Making

if/else— Execute based on condition

main.c

int age = 18;
if (age >= 18) {
    printf("Adult\n");
} else {
    printf("Minor\n");
}
// Output: Adult

switch/case/default— Multiple choices

main.c

int day = 3;
switch (day) {
    case 1: printf("Monday"); break;
    case 2: printf("Tuesday"); break;
    case 3: printf("Wednesday"); break;
    default: printf("Other day");
}
// Output: Wednesday

Loops

for— Loop with counter

main.c

for (int i = 0; i < 3; i++) {
    printf("%d ", i);
}
// Output: 0 1 2

while— Loop while condition is true

main.c

int x = 3;
while (x > 0) {
    printf("%d ", x);
    x--;
}
// Output: 3 2 1

do...while— Run at least once

main.c

int x = 0;
do {
    printf("Runs once!\n");
} while (x > 0);  // Condition is false, but runs once

break— Exit loop early

main.c

for (int i = 0; i < 10; i++) {
    if (i == 3) break;  // Stop!
    printf("%d ", i);
}
// Output: 0 1 2

continue— Skip to next

main.c

for (int i = 0; i < 5; i++) {
    if (i == 2) continue;  // Skip 2
    printf("%d ", i);
}
// Output: 0 1 3 4

goto— Jump to label (avoid if possible!)

main.c

int x = 0;
start:
    printf("%d ", x);
    x++;
    if (x < 3) goto start;  // Jump back
// Output: 0 1 2

goto makes code hard to read. Use loops instead!

return— Exit function, return value

main.c

int add(int a, int b) {
    return a + b;  // Exit and return result
}
int main() {
    int sum = add(5, 3);  // sum = 8
    return 0;  // Exit program successfully
}

05Storage Class Keywords

These keywords define where a variable is stored and how long it exists.

auto— Default for local variables (rarely written)

main.c

void func() {
    auto int x = 5;  // Same as just: int x = 5;
    int y = 10;      // auto is implied
}  // x and y are destroyed here

static— Value persists between function calls

main.c

void counter() {
    static int count = 0;  // Only initialized ONCE!
    count++;
    printf("Called %d times\n", count);
}
int main() {
    counter();  // Called 1 times
    counter();  // Called 2 times
    counter();  // Called 3 times
}

extern— Variable defined in another file

file1.c

main.c

int counter = 0;  // Definition

file2.c

main.c

extern int counter;  // Declaration
counter++;  // Uses counter from file1.c

main.c

register int i;  // Hint: store in CPU register
for (i = 0; i < 1000000; i++) {
    // Fast loop counter (historically)
}
// Modern compilers ignore this - they optimize better!

Obsolete. Let the compiler optimize.

06User-Defined Type Keywords

Create your own custom data types.

struct— Group related data together

main.c

struct Person {
    char name[50];
    int age;
};
struct Person john = {"John", 25};
printf("%s is %d\n", john.name, john.age);
// Output: John is 25

enum— Named integer constants

main.c

enum Day { MON, TUE, WED, THU, FRI };  // 0, 1, 2, 3, 4
enum Day today = WED;
if (today == WED) {
    printf("It's Wednesday!\n");
}

typedef— Create a type alias

main.c

typedef unsigned int uint;
typedef char* String;
uint count = 100;   // Same as: unsigned int count
String name = "Hi"; // Same as: char* name

union— Same memory, different types

main.c

union Data {
    int i;
    float f;
};  // Size = largest member (4 bytes)
union Data d;
d.i = 42;       // Store as int
d.f = 3.14f;    // Overwrites! Same memory location

07Other Important Keywords

These keywords serve special purposes.

sizeof— Get size in bytes

main.c

printf("int: %zu bytes\n", sizeof(int));      // 4
printf("char: %zu bytes\n", sizeof(char));    // 1
printf("double: %zu bytes\n", sizeof(double)); // 8
int arr[10];
printf("Array: %zu bytes\n", sizeof(arr));    // 40

const— Value cannot change (read-only)

main.c

const int MAX = 100;
const double PI = 3.14159;
// MAX = 200;  // ERROR! Can't modify const
printf("PI = %f\n", PI);

volatile— May change unexpectedly (hardware/threads)

main.c

volatile int sensor_value;  // Hardware might change this!
// Compiler won't optimize away reads
while (sensor_value == 0) {
    // Keep checking - value can change externally
}

Used for hardware registers, signal handlers, and multi-threaded code.

08Keywords by Category

Data Types (9)

intfloatdoublecharvoidshortlongsignedunsigned

Control Flow (12)

ifelseswitchcasedefaultforwhiledobreakcontinuegotoreturn

Storage Classes (4)

autostaticexternregister

User-Defined Types (4)

structunionenumtypedef

Other Keywords (3)

sizeofconstvolatile

!Code Pitfalls: Common Mistakes & What to Watch For

These are the most common mistakes that trip up beginners. Study them carefully to avoid hours of debugging!

Using Keywords as Variable Names

int for = 5; // ERROR: 'for' is a keyword

Wrong Case

IF (x > 5) // ERROR: should be lowercase 'if'

Misspelling Keywords

swicth (x) // ERROR: should be 'switch'

10Total Keywords by C Standard

C89/C90

Original Standard

C99

+5 new

C11

+7 new

~63

C23

+~19 new

Keyword Evolution

C89:The foundation - 32 keywords for basic C programming

C99:Added inline functions, booleans, complex numbers, restrict pointer

C11:Added threading, atomics, alignment, static assertions, generics

C23:Promoted macros to keywords, added constexpr, typeof, nullptr, _BitInt

Watch Out When Copying Code!

Key Takeaways

•C89 has 32 keywords, modern C23 has ~63 keywords
•All keywords are lowercase (except _Underscore prefixed ones)
•Keywords cannot be used as variable/function names
•Categories: Data Types, Control Flow, Storage Classes, User Types, Type Qualifiers
•C23 promotes many macros to proper keywords: bool, true, false, nullptr, alignas, alignof, static_assert
•Use -std=c99, -std=c11, or -std=c23 to enable newer keywords

Best Practice

Start with learning the 32 C89 keywords - they're used everywhere and work with all compilers. Then learn C99/C11 features as needed. C23 is cutting-edge and requires the latest compilers.

01What are Keywords?

Definition

Invalid

main.c

int int = 5;     // ERROR!
float return;    // ERROR!
char if = 'a';   // ERROR!

✓Valid

main.c

int number = 5;     // OK
float result;       // OK
char initial = 'a'; // OK

Key Points

• C has 32 keywords (C89/C90 standard)
• All keywords are in lowercase
• Keywords are case-sensitive (if ≠ IF)
• Cannot be used as variable/function names

02All 32 Keywords in C

Complete List of C Keywords (32 Total)

auto

break

case

char

const

continue

default

double

else

enum

extern

float

for

goto

int

long

return

short

signed

sizeof

static

struct

switch

typedef

union

unsigned

void

volatile

while

Note: Newer C Standards Added More

02bC99 Keywords (5 New)

The C99 standard (1999) introduced these new keywords:

Keyword	Purpose	Detailed Explanation
inline	Inline function hint	Suggests to the compiler to insert the function code directly at call site for better performance. Reduces function call overhead.
restrict	Pointer aliasing hint	Tells compiler that a pointer is the only way to access the object it points to. Enables aggressive optimizations.
_Bool	Boolean type	Native boolean type that can hold 0 (false) or 1 (true). Use <stdbool.h> for bool, true, false macros.
_Complex	Complex numbers	For complex number arithmetic. Use float _Complex, double _Complex. Include <complex.h> for complex macro.
_Imaginary	Imaginary numbers	For pure imaginary number types. Rarely implemented by compilers. Optional in C99.

c99_keywords.c

1#include <stdio.h>
2#include <stdbool.h>    // For bool, true, false
3#include <complex.h>    // For complex numbers
4
5// inline function - compiler may insert code directly
6inline int square(int x) {
7    return x * x;
8}
9
10// restrict - promise this is the only pointer to this memory
11void copy_array(int *restrict dest, const int *restrict src, int n) {
12    for (int i = 0; i < n; i++) {
13        dest[i] = src[i];
14    }
15}
16
17int main() {
18    // _Bool / bool usage
19    _Bool flag1 = 1;        // Raw C99 boolean
20    bool flag2 = true;      // With stdbool.h (preferred)
21    
22    printf("flag1: %d, flag2: %d\n", flag1, flag2);
23    printf("square(5): %d\n", square(5));
24    
25    // Complex numbers
26    double _Complex z = 3.0 + 4.0 * I;
27    printf("Complex: %.1f + %.1fi\n", creal(z), cimag(z));
28    
29    return 0;
30}

02cC11 Keywords (7 New)

The C11 standard (2011) added powerful new features:

Keyword	Macro Form	Detailed Explanation
_Alignas	alignas	Specifies memory alignment for a variable. _Alignas(16) int x; aligns x to 16-byte boundary.
_Alignof	alignof	Returns the alignment requirement of a type. Like sizeof but for alignment.
_Atomic	atomic_*	Declares atomic variables for lock-free thread-safe operations. Essential for multi-threaded programs.
_Generic	-	Type-generic selection. Enables function overloading by selecting code based on expression type at compile time.
_Noreturn	noreturn	Marks functions that never return (like exit(), abort()). Helps compiler optimize.
_Static_assert	static_assert	Compile-time assertion. Causes compilation error if condition is false. Great for catching errors early.
_Thread_local	thread_local	Each thread gets its own copy of the variable. Essential for thread-safe global state.

c11_keywords.c

1#include <stdio.h>
2#include <stdalign.h>   // For alignas, alignof
3#include <stdnoreturn.h> // For noreturn
4#include <stdatomic.h>  // For atomic types
5
6// Compile-time assertion
7_Static_assert(sizeof(int) >= 4, "int must be at least 4 bytes");
8
9// Function that never returns
10noreturn void fatal_error(const char *msg) {
11    printf("FATAL: %s\n", msg);
12    exit(1);
13}
14
15// Type-generic macro using _Generic
16#define print_type(x) _Generic((x), \
17    int: "int", \
18    float: "float", \
19    double: "double", \
20    char*: "string", \
21    default: "unknown")
22
23int main() {
24    // Memory alignment
25    alignas(16) int aligned_var = 42;
26    printf("Alignment of int: %zu\n", alignof(int));
27    printf("Alignment of aligned_var: %zu\n", alignof(aligned_var));
28    
29    // Atomic variable for thread safety
30    atomic_int counter = 0;
31    atomic_fetch_add(&counter, 1);  // Thread-safe increment
32    printf("Counter: %d\n", counter);
33    
34    // Type-generic selection
35    printf("Type of 42: %s\n", print_type(42));
36    printf("Type of 3.14: %s\n", print_type(3.14));
37    
38    // Thread-local (each thread has own copy)
39    _Thread_local static int per_thread_counter = 0;
40    per_thread_counter++;
41    
42    return 0;
43}

_Generic is Powerful!

_Generic enables "function overloading" in C by selecting different code paths based on type. The tgmath.h header uses this to make sin(), cos(), etc. work with float, double, and complex types!

02dC23 Keywords (Latest Standard) 🆕

The C23 standard (2023/2024) brings major improvements and new keywords:

Keyword	Status	Detailed Explanation
true	Now a keyword!	No longer a macro - true is a proper keyword. Value is 1.
false	Now a keyword!	No longer a macro - false is a proper keyword. Value is 0.
bool	Now a keyword!	Boolean type is now a native keyword. No need for <stdbool.h> anymore.
nullptr	New!	Type-safe null pointer constant. Better than NULL macro. Has type nullptr_t.
constexpr	New!	Compile-time constant expressions. Like const but evaluated at compile time. From C++!
typeof	Standardized!	Gets the type of an expression. Was a GCC extension, now standard. typeof(x) y; makes y same type as x.
typeof_unqual	New!	Like typeof but removes const/volatile qualifiers. typeof_unqual(const int) → int.
static_assert	Now a keyword!	Was _Static_assert with macro. Now a proper keyword. Message is optional in C23.
alignas	Now a keyword!	Was _Alignas with macro. Now a proper keyword.
alignof	Now a keyword!	Was _Alignof with macro. Now a proper keyword.
thread_local	Now a keyword!	Was _Thread_local with macro. Now a proper keyword.
_BitInt(N)	New!	Arbitrary-width integers! _BitInt(128) creates a 128-bit integer. N can be any positive integer.
_Decimal32/64/128	New!	Decimal floating-point types for precise financial calculations. No binary rounding errors!

c23_keywords.c

1// C23 Features - Use with -std=c23 compiler flag
2#include <stdio.h>
3// No need for <stdbool.h> in C23!
4
5int main() {
6    // bool, true, false are now keywords
7    bool is_valid = true;
8    bool is_empty = false;
9    
10    // nullptr - type-safe null pointer
11    int *ptr = nullptr;  // Better than NULL
12    if (ptr == nullptr) {
13        printf("Pointer is null\n");
14    }
15    
16    // constexpr - compile-time constants
17    constexpr int BUFFER_SIZE = 1024;
18    constexpr double PI = 3.14159265359;
19    
20    // typeof - get type of expression
21    int x = 42;
22    typeof(x) y = 100;  // y is also int
23    typeof(x + 1.0) z = 3.14;  // z is double
24    
25    // typeof_unqual - remove const/volatile
26    const int ci = 10;
27    typeof_unqual(ci) mutable_copy = ci;  // mutable_copy is int, not const int
28    mutable_copy = 20;  // OK, not const!
29    
30    // static_assert - no message required in C23
31    static_assert(sizeof(int) >= 4);  // Message optional!
32    static_assert(BUFFER_SIZE > 0, "Buffer must be positive");
33    
34    // _BitInt - arbitrary width integers
35    _BitInt(128) big_number = 12345678901234567890wb;
36    unsigned _BitInt(256) huge = 0;
37    
38    // Decimal floating point (if supported)
39    // _Decimal64 price = 19.99DD;  // No binary rounding errors!
40    
41    printf("is_valid: %d\n", is_valid);
42    printf("BUFFER_SIZE: %d\n", BUFFER_SIZE);
43    
44    return 0;
45}

✓C23 Simplifications

• No more #include <stdbool.h>
• nullptr replaces NULL
• Cleaner names: alignas vs _Alignas
• Optional message in static_assert

🆕 C23 New Features

• constexpr for compile-time eval
• typeof standardized
• _BitInt(N) arbitrary integers
• Decimal floating-point types

Compiler Support

C23 features require a recent compiler with -std=c23 or -std=c2x flag. GCC 13+, Clang 16+ have partial support. Check your compiler documentation for availability.

03Data Type Keywords

These keywords define the type of data a variable can hold.

int

4 bytes • Whole numbers

main.c

int age = 25;
int count = -10;
int sum = age + count;  // sum = 15

float

4 bytes

main.c

float price = 19.99f;  // f suffix!
float temp = -5.5f;

double

8 bytes • More precise

main.c

double pi = 3.14159265359;
double result = pi * 2;

char

1 byte • Single character

main.c

char grade = 'A';      // Use single quotes!
char newline = '\n';   // Special character
char digit = '5';      // Character, not number 5

void

"No type"

main.c

void sayHello(void) {   // Returns nothing, takes nothing
    printf("Hello!\n");
}
void *ptr;              // Generic pointer (any type)

short

2 bytes • Small range

main.c

short small = 32000;
short year = 2024;

long

4-8 bytes • Large range

main.c

long population = 8000000000L;
long long huge = 9223372036854775807LL;

signed

Negative + Positive

main.c

signed int temp = -10;  // Can be negative
int x = -5;             // signed by default

unsigned

Only 0 and Positive

main.c

unsigned int count = 0;   // 0 to 4 billion
unsigned char byte = 255; // 0 to 255

04Control Flow Keywords

These keywords control the flow of execution in your program.

Decision Making

if/else— Execute based on condition

main.c

int age = 18;
if (age >= 18) {
    printf("Adult\n");
} else {
    printf("Minor\n");
}
// Output: Adult

switch/case/default— Multiple choices

main.c

int day = 3;
switch (day) {
    case 1: printf("Monday"); break;
    case 2: printf("Tuesday"); break;
    case 3: printf("Wednesday"); break;
    default: printf("Other day");
}
// Output: Wednesday

Loops

for— Loop with counter

main.c

for (int i = 0; i < 3; i++) {
    printf("%d ", i);
}
// Output: 0 1 2

while— Loop while condition is true

main.c

int x = 3;
while (x > 0) {
    printf("%d ", x);
    x--;
}
// Output: 3 2 1

do...while— Run at least once

main.c

int x = 0;
do {
    printf("Runs once!\n");
} while (x > 0);  // Condition is false, but runs once

break— Exit loop early

main.c

for (int i = 0; i < 10; i++) {
    if (i == 3) break;  // Stop!
    printf("%d ", i);
}
// Output: 0 1 2

continue— Skip to next

main.c

for (int i = 0; i < 5; i++) {
    if (i == 2) continue;  // Skip 2
    printf("%d ", i);
}
// Output: 0 1 3 4

goto— Jump to label (avoid if possible!)

main.c

int x = 0;
start:
    printf("%d ", x);
    x++;
    if (x < 3) goto start;  // Jump back
// Output: 0 1 2

goto makes code hard to read. Use loops instead!

return— Exit function, return value

main.c

int add(int a, int b) {
    return a + b;  // Exit and return result
}
int main() {
    int sum = add(5, 3);  // sum = 8
    return 0;  // Exit program successfully
}

05Storage Class Keywords

These keywords define where a variable is stored and how long it exists.

auto— Default for local variables (rarely written)

main.c

void func() {
    auto int x = 5;  // Same as just: int x = 5;
    int y = 10;      // auto is implied
}  // x and y are destroyed here

static— Value persists between function calls

main.c

void counter() {
    static int count = 0;  // Only initialized ONCE!
    count++;
    printf("Called %d times\n", count);
}
int main() {
    counter();  // Called 1 times
    counter();  // Called 2 times
    counter();  // Called 3 times
}

extern— Variable defined in another file

file1.c

main.c

int counter = 0;  // Definition

file2.c

main.c

extern int counter;  // Declaration
counter++;  // Uses counter from file1.c

main.c

register int i;  // Hint: store in CPU register
for (i = 0; i < 1000000; i++) {
    // Fast loop counter (historically)
}
// Modern compilers ignore this - they optimize better!

Obsolete. Let the compiler optimize.

06User-Defined Type Keywords

Create your own custom data types.

struct— Group related data together

main.c

struct Person {
    char name[50];
    int age;
};
struct Person john = {"John", 25};
printf("%s is %d\n", john.name, john.age);
// Output: John is 25

enum— Named integer constants

main.c

enum Day { MON, TUE, WED, THU, FRI };  // 0, 1, 2, 3, 4
enum Day today = WED;
if (today == WED) {
    printf("It's Wednesday!\n");
}

typedef— Create a type alias

main.c

typedef unsigned int uint;
typedef char* String;
uint count = 100;   // Same as: unsigned int count
String name = "Hi"; // Same as: char* name

union— Same memory, different types

main.c

union Data {
    int i;
    float f;
};  // Size = largest member (4 bytes)
union Data d;
d.i = 42;       // Store as int
d.f = 3.14f;    // Overwrites! Same memory location

07Other Important Keywords

These keywords serve special purposes.

sizeof— Get size in bytes

main.c

printf("int: %zu bytes\n", sizeof(int));      // 4
printf("char: %zu bytes\n", sizeof(char));    // 1
printf("double: %zu bytes\n", sizeof(double)); // 8
int arr[10];
printf("Array: %zu bytes\n", sizeof(arr));    // 40

const— Value cannot change (read-only)

main.c

const int MAX = 100;
const double PI = 3.14159;
// MAX = 200;  // ERROR! Can't modify const
printf("PI = %f\n", PI);

volatile— May change unexpectedly (hardware/threads)

main.c

volatile int sensor_value;  // Hardware might change this!
// Compiler won't optimize away reads
while (sensor_value == 0) {
    // Keep checking - value can change externally
}

Used for hardware registers, signal handlers, and multi-threaded code.

08Keywords by Category

Data Types (9)

intfloatdoublecharvoidshortlongsignedunsigned

Control Flow (12)

ifelseswitchcasedefaultforwhiledobreakcontinuegotoreturn

Storage Classes (4)

autostaticexternregister

User-Defined Types (4)

structunionenumtypedef

Other Keywords (3)

sizeofconstvolatile

!Code Pitfalls: Common Mistakes & What to Watch For

These are the most common mistakes that trip up beginners. Study them carefully to avoid hours of debugging!

Using Keywords as Variable Names

int for = 5; // ERROR: 'for' is a keyword

Wrong Case

IF (x > 5) // ERROR: should be lowercase 'if'

Misspelling Keywords

swicth (x) // ERROR: should be 'switch'

10Total Keywords by C Standard

C89/C90

Original Standard

C99

+5 new

C11

+7 new

~63

C23

+~19 new

Keyword Evolution

C89:The foundation - 32 keywords for basic C programming

C99:Added inline functions, booleans, complex numbers, restrict pointer

C11:Added threading, atomics, alignment, static assertions, generics

C23:Promoted macros to keywords, added constexpr, typeof, nullptr, _BitInt

Watch Out When Copying Code!

Key Takeaways

•C89 has 32 keywords, modern C23 has ~63 keywords
•All keywords are lowercase (except _Underscore prefixed ones)
•Keywords cannot be used as variable/function names
•Categories: Data Types, Control Flow, Storage Classes, User Types, Type Qualifiers
•C23 promotes many macros to proper keywords: bool, true, false, nullptr, alignas, alignof, static_assert
•Use -std=c99, -std=c11, or -std=c23 to enable newer keywords

Best Practice

Start with learning the 32 C89 keywords - they're used everywhere and work with all compilers. Then learn C99/C11 features as needed. C23 is cutting-edge and requires the latest compilers.

What You Will Learn

01What are Keywords?

Definition

Invalid

✓Valid

Key Points

02All 32 Keywords in C

Complete List of C Keywords (32 Total)

Note: Newer C Standards Added More

02bC99 Keywords (5 New)

02cC11 Keywords (7 New)

_Generic is Powerful!

02dC23 Keywords (Latest Standard) 🆕

✓C23 Simplifications

🆕 C23 New Features

Compiler Support

03Data Type Keywords

int

float

double

char

void

short

long

signed

unsigned

04Control Flow Keywords

Decision Making

Loops

05Storage Class Keywords

06User-Defined Type Keywords

07Other Important Keywords

08Keywords by Category

Data Types (9)

Control Flow (12)

Storage Classes (4)

User-Defined Types (4)

Other Keywords (3)

!Code Pitfalls: Common Mistakes & What to Watch For

Using Keywords as Variable Names

Wrong Case

Misspelling Keywords

10Total Keywords by C Standard

Keyword Evolution

Watch Out When Copying Code!

Key Takeaways

Best Practice

Test Your Knowledge

Related Tutorials

Identifiers in C

Data Types & Variables

Input/Output in C

Have Feedback?

What You Will Learn

01What are Keywords?

Definition

Invalid

✓Valid

Key Points

02All 32 Keywords in C

Complete List of C Keywords (32 Total)

Note: Newer C Standards Added More

02bC99 Keywords (5 New)

02cC11 Keywords (7 New)

_Generic is Powerful!

02dC23 Keywords (Latest Standard) 🆕

✓C23 Simplifications

🆕 C23 New Features

Compiler Support

03Data Type Keywords

int

float

double

char

void

short

long

signed

unsigned

04Control Flow Keywords