Introduction to Keywords in C

In C programming, keywords are reserved words that have a predefined meaning and cannot be used as identifiers (variable names, function names, etc.). Keywords are integral to the syntax of the C language and perform specific actions. In C there are 32 keywords in C.

List of Keywords in C

The C language has a set of standard keywords. Below is a list of commonly used C keywords:

• Data Type Keywords: int, float, double, char
• Control Keywords: if, else, switch, case
• Loop Keywords: for, while, do, break, continue
• Function and Structure Keywords: return, void, struct, sizeof
• Storage Class Keywords: auto, register, static, extern
• Other Keywords: const, enum, goto, volatile

Here is the list of 32 keywords in C:

• auto: Declares a local variable with automatic storage duration (default for local variables).
• break: Exits a loop or switch statement early.
• case: Defines a specific condition to execute within a switch statement.
• char: Defines a character data type.
• const: Declares a variable as constant, preventing modification.
• continue: Skips the current iteration in a loop and moves to the next one.
• default: Executes a block of code if no case matches in a switch.
• do: Runs a loop that executes at least once before checking the condition.
• double: Defines a double-precision floating-point data type.
• else: Provides an alternative block of code if the if condition is false.
• enum: Defines a set of named integer constants.
• extern: Declares a variable that is defined in another file or scope.
• float: Defines a floating-point data type.
• for: Initiates a loop that repeats until a specified condition is met.
• goto: Transfers control to a labeled statement within the program.
• if: Starts a conditional statement to execute code based on a condition.
• int: Defines an integer data type.
• long: Modifies data types to allow larger storage.
• register: Suggests that a variable be stored in a register for faster access.
• return: Exits a function and optionally returns a value.
• short: Modifies data types to use less storage.
• signed: Declares a signed data type, allowing both positive and negative values.
• sizeof: Returns the size of a data type or variable in bytes.
• static: Preserves a variable’s value between function calls or restricts scope to a file.
• struct: Defines a structure, grouping variables of different types.
• switch: Allows multiple conditional checks within one statement.
• typedef: Defines a new name (alias) for a data type.
• union: Allows storage of different data types in the same memory location.
• unsigned: Declares an unsigned data type, allowing only positive values.
• void: Specifies that a function does not return a value or is used for pointer declarations.
• volatile: Informs the compiler that a variable may change unexpectedly.
• while: Initiates a loop that repeats as long as a specified condition is true.

Examples of Common Keywords in C

Below are examples demonstrating the use of several common keywords in C:

Example 1: Using Data Type Keywords

int age = 25;
float height = 5.9;
char grade = 'A';

In this example, int, float, and char are data type keywords that define the type of variables.

Example 2: Using Control and Loop Keywords

int i;
for (i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    printf("%d is odd\n", i);
}

Here, for, if, and continue are control and loop keywords that manage the flow of the program.

Example 3: Using Storage Class Keywords

static int count = 0;
extern int globalVar;

The keyword static specifies a persistent storage class, while extern is used to declare an external variable.

Best Practices for Using Keywords

• Understand each keyword’s function: Learn the purpose and usage of each keyword before using it in your code.
• Avoid using keywords as identifiers: This will result in errors, as keywords have predefined meanings.
• Use appropriate keywords for better readability: Choose keywords that clearly express the purpose of your code sections (e.g., using const for constants).

Conclusion