3 Essential C Keywords Every Interview Covers

1. The Role of the static Keyword

#

The static keyword changes the lifetime of a variable or function, but not its scope. Its meaning depends on where it’s applied:

• Static local variable:
  A static local variable retains its value between function calls. It’s initialized only once and isn’t destroyed when the function exits.

• Static global variable:
  A static global variable can only be accessed within the file it’s defined in, preventing naming conflicts across files.

• Static function:
  A static function is only visible within its own source file. This limits linkage and avoids symbol collisions during linking.

All static objects are stored in the static memory segment and are automatically initialized to zero if no explicit initializer is provided.

2. The Role of the const Keyword

#

const (short for constant) declares variables whose values cannot be modified after initialization. It helps ensure data safety and makes intent clear to both the compiler and other developers.

2.1 const with Local Variables

#

A const local variable must be initialized when declared, since it cannot be reassigned later.

const int i = 10;   // valid
int const j = 10;   // equivalent form
i = 20;             // error: cannot modify a const value
const int k;        // error: must be initialized

2.2 const with Pointers

#

There are three common const-pointer combinations in C:

(1) Pointer to Constant

#

The pointer can change, but the data it points to cannot.

const int* p = &a;
int const* p = &a;  // equivalent
*p = 6;  // error
p = &b;  // valid

(2) Constant Pointer

#

The pointer itself cannot change, but the data it points to can.

int x = 10;
int* const ptr = &x;
*ptr = 40;  // valid
ptr = &y;   // error

(3) Constant Pointer to Constant

#

Neither the pointer nor the pointed data can change.

const int n1 = 5;
const int n2 = 15;
const int* const p = &n1;
// *p = 55;   // error
// p = &n2;   // error

Mnemonic: Read C declarations right to left. Example:

char * const cp;  // cp is a constant pointer to char
const char * p;   // p is a pointer to a constant char

2.3 const in Function Parameters

#

Using const in function arguments improves code safety and clarity.

a) Protecting Input Data

#

void StringCopy(char* dest, const char* src);

Here, src is read-only; attempts to modify it cause a compile-time error.

b) Protecting Pointer Addresses

#

void swap(int* const p1, int* const p2);

Both p1 and p2 cannot be redirected to other addresses.

c) Combining Both

#

void swap(int* const p1, const int* const p2);

2.4 const in Function Return Values

#

If a function returns a pointer marked const, its contents cannot be modified:

const char* GetString(void);
char* str = GetString();       // error
const char* str = GetString(); // valid

3. The Role of the volatile Keyword

#

volatile tells the compiler that a variable may change unexpectedly — such as in hardware registers, interrupt routines, or multi-threaded programs. It prevents compiler optimizations that assume variable values remain constant.

Common use cases:

• Memory-mapped I/O registers
• Global variables modified by ISRs (interrupt service routines)
• Shared variables in multithreaded programs

By declaring a variable volatile, the compiler always fetches its latest value from memory rather than using a cached register copy.

Compiler Optimization Example

#

Without volatile, the compiler may cache a variable’s value in a register:

int flag = 0;
while (flag == 0) { ... }  // may never see external updates to flag

Using volatile forces memory reads every iteration:

volatile int flag = 0;
while (flag == 0) { ... }  // always reads the latest value

This ensures consistent behavior across hardware registers, interrupt-driven updates, and multi-threaded contexts.

Summary

#

Together, static, const, and volatile form the foundation of safe, efficient C programming — and mastering their nuances is key to acing any C language interview.