Keywords in C Language: C programming language has 32 keywords, each with a specific

function.

auto char const float

double int long struct

switch case break default

continue short signed register

if else do while

for goto void enum

extern sizeof typedef union

unsigned volatile return static

1. auto:
 Explanation: The auto keyword is used to declare automatic variables. These are local
variables which are automatically created and destroyed when the program flow enters
and exits the block in which they are defined. In modern C, auto is the default storage
class for local variables, so it is rarely used explicitly.

Example: int main()

{
auto int x = 10; // 'auto' is optional, same as 'int x = 10;'
printf("%d", x);
return 0;
}
2. char:

 Explanation: The char keyword is used to declare variables that can hold a single
character. Characters in C are stored as integers, using the ASCII value of the character.

Example: int main()

{
char letter = 'A';
printf("%c", letter);
return 0;
}
// Output: A
3. const:

 Explanation: The const keyword is used to declare variables whose value cannot be
changed after initialization. It can be applied to any data type.

Example: int main()

{
const int x = 5;
x = 10; // Error: cannot modify a constant variable
printf("%d", x);
return 0;
}
// Output: 5

4. float

 Explanation: The float keyword is used to declare variables of type float, a single-
precision floating-point data type (typically 32 bits).

Example: int main()

{
float pi = 3.14f;
printf("%f", pi);
return 0;
}
// Output: 3.140000

5. double:

 Explanation: The double keyword is used to declare variables of type double for a
floating-point data type that offers more precision (typically 64 bits) compared to float
(32 bits).

Example: int main()

{
double pi = 3.14159;
printf("%lf", pi);
return 0;
}
// Output: 3.141590
6. int

 Explanation: The int keyword is used to declare variables of type int, which represents
integers. The size of an int typically depends on the system but is often 32 bits.

Example: int main() {

int number = 10;
printf("%d", number);
return 0;
}
// Output: 10

7. long

 Explanation: The long keyword is used to declare variables of type long, a data type that
can hold larger integer values compared to int. It can also be used with double for double-
precision floating-point variables.

Example: int main()

{
long int num = 123456789L;
printf("%ld", num);
return 0;
}
// Output: 123456789

8. struct

 Explanation: The struct keyword is used to define a structure, a user-defined data type
that allows grouping variables of different types under a single name.

Example: struct Point // Define a structure named 'Point'

{
int x; // x-coordinate
int y; // y-coordinate
};
int main()
{
struct Point p1; // Declare a variable of type 'struct Point'
// Assign values to the members of the structure
p1.x = 10;
p1.y = 20;
// Print the values of the structure members
 printf("x = %d, y = %d", p1.x, p1.y);
return 0;
}
// Output: x = 10, y = 20

9. switch

 Explanation: The switch keyword is used to create a switch statement, which tests a
variable against a series of constant values and executes the corresponding code block for
the matching value.

Example: int main()

{
int num = 2;
switch (num) {
case 1:
printf("One");
break;
case 2:
printf("Two");
break;
default:
printf("Other");
}
return 0;
}
// Output: Two

10. case:

 Explanation: The case keyword is used within a switch statement to define individual
conditions (cases) that can match the value of the variable being evaluated. Each case is
followed by a constant expression and a colon.

Example: int main() {

int num = 2;
switch (num) {
case 1:
printf("One");
break;
case 2:
 printf("Two");
break;
default:
printf("Other");
}
return 0;
}
// Output: Two

11. break:

 Explanation: The break statement is used to exit from the nearest enclosing loop or
switch statement. When break is encountered inside a loop, the loop is immediately
terminated, and control resumes at the next statement following the loop.

Example: int main()

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

12. default

 Explanation: The default keyword is used in a switch statement to specify the block of
code that should execute if no case matches the switch expression.

Example: int main()

{
int num = 3;
switch (num) {
case 1:
printf("One");
break;
case 2:
printf("Two");
break;
default:
printf("Other");
 }
return 0;
}
// Output: Other

13. continue

 Explanation: The continue statement skips the remaining code in the current iteration of
the loop and proceeds to the next iteration. It's often used with if statements to skip
certain conditions.

Example: int main()

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

14. short

 Explanation: The short keyword is used to declare variables of type short int, a data type
that typically uses less memory (16 bits) than int. It is useful when memory usage is a
concern.

Example: int main()

{
short int num = 32767;
printf("%d", num);
return 0;
}
// Output: 32767

15. signed

 Explanation: The signed keyword is used to declare variables that can store both
positive and negative numbers. It is the default for int data types.

Example: int main()

{
 signed int num = -10;
printf("%d", num);
return 0;
}
// Output: -10

16. register

 Explanation: The register keyword suggests that the compiler store the variable in a
CPU register instead of RAM for faster access. However, it's merely a suggestion, and the
compiler may ignore it.

Example: int main()

{
register int x = 5;
printf("%d", x);
return 0;
}
// Output: 5

17. if

 Explanation: The if keyword is used to execute a block of code if a specified condition

is true. It is the primary decision-making structure in C.

Example: int main()

{
int x = 5;
if (x > 0)
{
printf("Positive");
}
return 0;
}
// Output: Positive

18. else:

 Explanation: The else keyword is used in conjunction with if to execute a block of code
if the if condition is false. It is used to handle alternative conditions.
 Example: int main()
{
int x = 5;
if (x > 0) {
printf("Positive");
}
else
{
printf("Negative");
}
return 0;
}
// Output: Positive

19. do:

 Explanation: The do keyword is used in conjunction with while to create a do-while

loop, which is similar to a while loop, except that the block of code is executed at least
once before the condition is tested.

Example: int main()

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

20. while

 Explanation: The while keyword is used to create a loop that executes as long as a
specified condition is true. It is a pre-tested loop, meaning the condition is checked before
executing the loop's code.

Example: int main()

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

21. for

 Explanation: The for keyword is used to create a loop that repeats a block of code a
specified number of times. It consists of an initialization, a condition, and an
increment/decrement expression.

Example: int main() {

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

22. goto

 Explanation: The goto keyword transfers control to a labeled statement within the same
function. It is generally discouraged because it can make the code difficult to follow and
debug.

Example: int main()

{
int x = 0;
if (x == 0) goto label;
printf("This won't print.");
label:
printf("Goto label");
return 0;
}
// Output: Goto label

23. void
  Explanation: The void keyword is used to indicate that a function does not return a
value. It is also used to declare pointers to an unknown data type.

Example: void printHello()

{
printf("Hello");
}
int main() {
printHello();
return 0;
}
// Output: Hello

24. enum:

 Explanation: The enum keyword is used to define an enumerated type, which is a set of
named integer constants. Each name in the enum corresponds to an integer value, starting
at 0 by default and incrementing by 1 for each subsequent name.

Example: enum week {Sun, Mon, Tue, Wed, Thu, Fri, Sat};
int main()
{
enum week today = Wed;
printf("%d", today); // Outputs 3 (index of Wed)
return 0;
}
// Output: 3
25. extern

 Explanation: The extern keyword is used to declare a global variable or function in

another file or later in the same file. It is used to extend the visibility of
variables/functions across multiple files.

Example: File1.c
#include <stdio.h>
int value = 10; // Define the variable
void displayvalue() // Function to display the variable
{
printf("Value from file1.c: %d\n", value);
}
 File2.c
#include <stdio.h>

// Declare the external variable

extern int value;

// Declare the external function

extern void displayvalue();

int main() {
// Use the external function
displayvalue();

// Access and print the external variable

printf("Value from file2.c: %d\n", value);

return 0;
}

26. sizeof

 Explanation: The sizeof keyword is used to determine the size (in bytes) of a data type
or a variable. It is often used for memory allocation.

Example: int main()

{
int x;
printf("Size of int: %lu bytes", sizeof(x));
return 0;
}
// Output: Size of int: 4 bytes

27. typedef

 Explanation: The typedef keyword is used to create a new name (alias) for an existing
data type. It is commonly used for simplifying complex type declarations.

Example: typedef unsigned long int ULI;

int main() {
ULI num = 1234567890;
printf("%lu", num);
return 0;
 }
// Output: 1234567890

28. union

 Explanation: The union keyword is used to define a union, a user-defined data type that
allows storing different data types in the same memory location. Only one member can
hold a value at a time.

Example: union Data

{
int i;
float f;
char str[20];
};
int main()
{
union Data data;
data.i = 10;
printf("data.i = %d\n", data.i);
data.f = 220.5;
printf("data.f = %.1f\n", data.f);
strcpy(data.str, "C Programming");
printf("data.str = %s\n", data.str);
return 0;
}
// Output:

// data.i = 10

// data.f = 220.5

// data.str = C Programming

29. unsigned

 Explanation: The unsigned keyword is used to declare variables that can only store non-
negative numbers. It increases the maximum range of the variable but removes the ability
to store negative values.

Example: int main()

{
unsigned int num = 10;
printf("%u", num);
 return 0;
}
// Output: 10

30. volatile

 Explanation: The volatile keyword is used to indicate that a variable's value may change
unexpectedly, such as from hardware or another thread. It prevents the compiler from
optimizing code that reads or writes the variable.

Example: int main()

{
volatile int x = 10;
// The compiler will not optimize the following line:
x = 20;
printf("%d", x);
return 0;
}
// Output: 20

31. return

 Explanation: The return keyword terminates the execution of a function and returns
control to the calling function. Optionally, it can return a value to the calling function.

Example: int add(int a, int b)

{
return a + b;
}
int main()
{
int sum = add(3, 4);
printf("%d", sum);
return 0;
}
// Output: 7

32. static
  Explanation: The static keyword has several uses. When applied to a variable within a
function, it retains its value between function calls. When used with global variables, it
restricts their scope to the file in which they are declared. In a function, it limits the
visibility to the current file.

Example: void func()

{
static int count = 0;
count++;
printf("%d ", count);
}
int main()
{
func();
func();
func();
return 0;
}
// Output: 1 2 3