Top 80+ C Interview Questions and Answers You Must Prepare in 2026

The sizeof operator in C is used to determine the size (in bytes) of a variable, data type, or expression. It is evaluated at compile time (except in the case of variable-length arrays in C99).

It can be used in three common ways:

sizeof(int);
sizeof(variable);
sizeof(expression);

One of the most important points, and a very commonly asked interview twist, is that sizeof() does not evaluate the expression passed to it.

Example:

int a = 5;
printf("%zu", sizeof(a++));

Even though a++ is written inside sizeof, the value of a remains 5 because the expression is never executed. Only its type is considered to determine memory size.

Another key interview concept is how sizeof behaves with arrays versus pointers.

int arr[10];
int *ptr = arr;
printf("%zu", sizeof(arr));  // 40 (if int is 4 bytes)
printf("%zu", sizeof(ptr));  // 8 (on 64-bit system)

• sizeof(arr) returns the total memory allocated for the entire array.
   
• sizeof(ptr) returns only the size of the pointer (typically 4 bytes on 32-bit systems or 8 bytes on 64-bit systems).
   

This distinction becomes especially important when arrays are passed to functions, because arrays decay into pointers, and sizeof inside the function will return the pointer size, not the full array size.

This question is extremely common in fresher-level interviews because it tests memory understanding and compile-time behavior.

Arrays and pointers are closely related in C, but they are not the same.

An array allocates a fixed block of contiguous memory, whereas a pointer stores the address of a memory location.

Example:

int arr[5];
int *ptr = arr;

Key differences include:

1. Memory Allocation
   An array allocates memory for all elements at compile time.
   A pointer only stores an address.
    
2. Size Behavior
   sizeof(arr) returns total array size.
   sizeof(ptr) returns size of pointer (4 or 8 bytes).
    
3. Reassignment
   Array name cannot be reassigned:
   
    

arr = ptr; // Error

Pointer can be reassigned:

 

ptr = anotherArray;

• Fixed vs Flexible
  Array size is fixed at declaration (unless dynamic allocation is used).
  Pointer can point to different memory locations dynamically.
   
• Address Operator
  &arr gives address of the entire array.
  &ptr gives address of the pointer variable itself.
   

Another important interview concept is array decay. When an array is passed to a function, it decays into a pointer to its first element.

void func(int arr[]) {
   printf("%zu", sizeof(arr));  // prints pointer size
}

Inside the function, sizeof(arr) does not return the full array size because it is treated as a pointer.

Storage classes in C define the scope, lifetime, and memory location of variables. There are four primary storage classes: auto, extern, static, and register.

1. auto

The auto storage class is the default for local variables declared inside functions. These variables are stored in stack memory and exist only during the execution of the block in which they are defined.

Example:

void func() {
   auto int x = 10;
}

• Scope: Local to block
• Lifetime: Until function exits
• Default value: Garbage (uninitialized)

2. extern

The extern keyword is used to declare a variable that is defined in another file. It enables cross-file access of global variables.

File1.c:

int globalVar = 100;

File2.c:

extern int globalVar;

• Scope: Global
• Lifetime: Entire program execution
• Default value: 0 (for global variables)

3. static

The static storage class behaves differently depending on where it is used.

If declared inside a function, it preserves its value between function calls.

void counter() {
   static int count = 0;
   count++;
   printf("%d", count);
}

Here, count retains its value across multiple calls.

If declared outside a function (global static variable), it restricts visibility to the same file.

• Scope (local static): Local to function
• Scope (global static): Limited to file
• Lifetime: Entire program execution
• Default value: 0

4. register

The register keyword suggests storing the variable in a CPU register for faster access. However, modern compilers usually ignore this suggestion and optimize automatically.

Example:

void func() {
   register int i;
}

• Scope: Local
• Lifetime: Until block exits
• Cannot use & operator on register variable (address cannot be accessed)

A NULL pointer is a pointer that does not point to any valid memory location. It is typically defined as:

#define NULL ((void*)0)

When a pointer is assigned NULL, it explicitly indicates that it is not currently pointing to a valid object.

Example:

int *ptr = NULL;

If you attempt to dereference a NULL pointer:

printf("%d", *ptr);

the behavior is undefined. In most operating systems, this results in a segmentation fault (runtime crash) because the program attempts to access memory address 0, which is protected.

Best practices in C programming include:

• Always initialize pointers to NULL if not immediately assigned.
• Always check if a pointer is NULL before dereferencing.

Example:

if (ptr != NULL) {
   printf("%d", *ptr);
}

It is also important to understand the difference between NULL, 0, and '\0':

• NULL - Represents a null pointer.
• 0 - An integer constant; can also represent a null pointer in pointer context.
• '\0' - Null character used to terminate strings.

C provides file handling through the FILE structure defined in <stdio.h>. All file operations are performed using a FILE* pointer.

To open a file:

FILE *fp = fopen("file.txt", "r");

Common modes include:

• "r" - Read
• "w" - Write (overwrites file)
• "a" - Append
• "r+", "w+", "a+" - Read and write
• "rb", "wb" - Binary modes

After finishing operations, the file must be closed:

fclose(fp);

To write formatted text:

fprintf(fp, "%d", value);

To read formatted input:

fscanf(fp, "%d", &value);

For binary file operations:

fread(buffer, size, count, fp);
fwrite(buffer, size, count, fp);

Additional useful functions include:

• fseek() - Move file pointer
• ftell() - Get current position
• feof() - Check end-of-file
• ferror() - Detect errors

File handling is essential for persistent storage, logging systems, configuration management, and data processing applications.

In C, memory is primarily divided into stack and heap.

The stack is used for automatic memory allocation. It stores local variables, function parameters, and call frames. Stack memory follows a Last-In-First-Out (LIFO) structure.

Example:

void func() {
   int x = 10;  // stored on stack
}

Stack characteristics:

• Automatically managed
• Very fast allocation and deallocation
• Limited size (typically 1-8 MB depending on system)
• Thread-specific
• Can cause stack overflow if memory exceeds limit

The heap is used for dynamic memory allocation using functions like malloc(), calloc(), and free().

Example:

int *ptr = (int*)malloc(sizeof(int));

Heap characteristics:

• Manually managed
• Larger memory area (limited by system RAM)
• Slower allocation compared to stack
• Shared across threads
• Can cause memory leaks if not freed

Stack allocation is faster because it simply moves the stack pointer. Heap allocation requires searching free memory blocks and managing fragmentation.

Understanding stack vs heap is fundamental because many runtime issues, including segmentation faults and memory leaks, originate from improper memory management.

A segmentation fault (SIGSEGV) occurs when a program attempts to access memory that it does not have permission to access. The operating system immediately terminates the program to prevent memory corruption.

Common causes include:

1. Dereferencing a NULL or uninitialized pointer
2. Accessing array elements out of bounds
3. Writing to read-only memory (e.g., modifying string literals)
4. Using memory after it has been freed (dangling pointer)
5. Stack overflow due to deep or infinite recursion

Example of NULL dereferencing:

int *ptr = NULL;
*ptr = 10;   // Causes segmentation fault

Example of writing to read-only memory:

char *str = "Hello";
str[0] = 'h';   // Undefined behavior

Segmentation faults are runtime errors and indicate invalid memory access. They are commonly debugged using tools such as:

• gdb (GNU Debugger)
• Valgrind
• AddressSanitizer

A function pointer is a pointer that stores the address of a function. It allows functions to be passed as arguments, returned from functions, or stored in data structures.

Declaration syntax:

int (*fptr)(int, int);

This means fptr is a pointer to a function that takes two integers and returns an integer.

Example:

int add(int a, int b) {
   return a + b;
}

int (*fptr)(int, int);
fptr = &add;
int result = fptr(3, 5);        // or (*fptr)(3, 5)

Both calling styles are valid.

Function pointers are commonly used in:

• Callback functions
• Implementing function dispatch tables
• State machines
• Standard library functions like qsort() (custom comparator)

For better readability, typedef is often used:

typedef int (*Operation)(int, int);
Operation op = add;

You can also create arrays of function pointers, useful in menu-driven programs:

int (*operations[2])(int, int) = {add, subtract};

The volatile keyword tells the compiler that a variable’s value may change at any time without any action from the surrounding code. Because of this, the compiler must not apply optimizations that assume the variable remains unchanged.

Normally, compilers optimize code by storing frequently used variables in registers or eliminating repeated reads. However, if a variable is declared as volatile, the compiler is forced to read its value from memory every time it is accessed.

Syntax:

volatile int flag;

The volatile keyword is typically used in the following situations:

• Memory-mapped hardware registers (embedded systems)
• Variables modified by Interrupt Service Routines (ISR)
• Variables shared between multiple threads

For example, in embedded systems:

volatile int statusRegister;

Here, the value of statusRegister may change due to hardware activity, not program logic.

It is also important to understand the difference between volatile and const.

• const - The program cannot modify the variable.
• volatile - The compiler cannot optimize the variable.

A variable can be both const and volatile. For example:

const volatile int hardwareStatus;

This is common for read-only hardware registers whose values change externally.

This is one of the most important intermediate-level questions because it tests knowledge of compiler behavior and low-level system concepts.

In C, command line arguments allow a program to receive input directly when it is executed from the terminal. Instead of writing input inside the program, values can be passed during execution.

The main() function can be written as:

int main(int argc, char *argv[])

Here:

• argc (argument count) stores the number of command line arguments.
• argv (argument vector) is an array of strings representing those arguments.

Important points:

• argv[0] always contains the program name.
• argc is always at least 1.
• argv[argc] is always NULL.

Example program to add two numbers passed via command line:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
   if (argc != 3) {
       printf("Usage: %s num1 num2\n", argv[0]);
       return 1;
   }
   int num1 = atoi(argv[1]);
   int num2 = atoi(argv[2]);
   printf("Sum = %d\n", num1 + num2);
   return 0;
}

If executed as:

./program 10 20

Output:

Sum = 30

Since command line arguments are passed as strings, functions like atoi() or atof() are used to convert them into integers or floating-point numbers.

Structure padding refers to the extra bytes added by the compiler between structure members to ensure proper memory alignment. Alignment ensures that data is stored at memory addresses that match the CPU’s natural word boundaries, which improves performance.

Consider this structure:

struct Example {
   char a;
   int b;
   char c;
};

Although the sum of member sizes is 1 + 4 + 1 = 6 bytes, the actual size may be 12 bytes.

This happens because:

• int typically requires 4-byte alignment.
• The compiler inserts padding after char a so that int b starts at a 4-byte boundary.
• Additional padding may be added at the end to align the structure size to the largest member.

This is why:

sizeof(struct Example)

may return 12 instead of 6.

Padding improves performance because many CPUs read aligned memory faster, and some architectures cannot read misaligned memory at all.

You can control or reduce padding in several ways:

1. Reordering structure members from largest to smallest:
    

struct Optimized {
   int b;
   char a;
   char c;
};

1. Using compiler directives such as:
    

#pragma pack(1)

or in GCC:

__attribute__((packed))

These disable padding, but may reduce performance due to misaligned memory access.

You can also use the offsetof() macro to check the offset of structure members and analyze alignment behavior.

Bit-fields allow you to specify the exact number of bits that a structure member should occupy. Instead of using full bytes for each variable, you can allocate only the number of bits required.

Example:

struct Flags {
   unsigned int flag : 1;
   unsigned int mode : 3;
   unsigned int id   : 4;
};

Here:

• flag uses 1 bit
• mode uses 3 bits
• id uses 4 bits

Together, they occupy 8 bits (1 byte), instead of 12 bytes if three normal int variables were used.

Bit-fields are commonly used in:

• Memory-constrained systems
• Embedded systems
• Hardware register mapping
• Protocol header implementation
• Packed data structures

Important limitations and considerations:

• You cannot take the address of a bit-field.
• The behavior of signed bit-fields is implementation-defined.
• Alignment and padding may still apply depending on compiler and architecture.
• Bit ordering may differ between systems (endianness considerations).

Bit-fields are especially useful when working close to hardware or optimizing memory usage in large-scale systems.

UART, SPI, and I2C are commonly used serial communication protocols in embedded systems. Each has distinct characteristics and trade-offs.

UART (Universal Asynchronous Receiver/Transmitter)

UART is asynchronous communication. It uses two main wires:

• TX (Transmit)
• RX (Receive)

There is no clock line. Synchronization happens using start and stop bits. Typical baud rates range from 9600 to 115200, though higher speeds are possible.

UART is simple and commonly used for:

• Debug consoles
• GPS modules
• Bluetooth modules
• PC communication

Basic UART initialization pattern (simplified):

UART->BAUD = 9600;
UART->CTRL = UART_ENABLE | UART_TX_ENABLE | UART_RX_ENABLE;

UART is ideal for point-to-point communication over moderate distances.

SPI (Serial Peripheral Interface)

SPI is synchronous and uses four wires:

• MOSI (Master Out Slave In)
• MISO (Master In Slave Out)
• SCLK (Clock)
• SS (Slave Select)

It supports full-duplex communication and can run at very high speeds (tens of MHz).

SPI is typically used for:

• SD cards
• Displays
• Flash memory
• High-speed sensors

It requires a separate chip select line for each slave device.

SPI is preferred when speed is critical and extra GPIO pins are available.

I2C (Inter-Integrated Circuit)

I2C is synchronous but uses only two wires:

• SDA (Data)
• SCL (Clock)

It supports multiple masters and multiple slaves. Devices are addressed using 7-bit or 10-bit addresses.

I2C is slower than SPI but requires fewer pins.

It is commonly used for:

• Temperature sensors
• EEPROM
• Real-time clocks
• Low-speed peripheral devices

I2C is preferred when:

• Pin count is limited
• Multiple devices share the same bus
• Communication speed is moderate

When to Choose Each?

• Choose UART for simple, point-to-point communication.
• Choose SPI for high-speed data transfer.
• Choose I2C when you need multiple devices on minimal wiring.

Endianness defines how multi-byte data types (such as 16-bit or 32-bit integers) are stored in memory.

In little-endian systems, the Least Significant Byte (LSB) is stored at the lowest memory address. This is the default for x86 and most ARM systems.

For example, the 32-bit value:

0x12345678

is stored in memory as:

78 56 34 12

In big-endian systems, the Most Significant Byte (MSB) is stored at the lowest address:

12 34 56 78

Network protocols use big-endian format, also called “network byte order.”

Endianness matters in Embedded C for several reasons:

• Cross-platform communication (networking uses big-endian)
• Reading binary data from files or sensors
• Interpreting memory-mapped data
• Type casting between char* and int*

Standard conversion functions include:

• htonl() - host to network long
• ntohl() - network to host long
• htons() - host to network short
• ntohs() - network to host short
   

You can detect endianness at runtime using:

union {
   uint32_t i;
   uint8_t c[4];
} test = { .i = 1 };

if (test.c[0] == 1) {
   // Little-endian
}

Some ARM processors are bi-endian, which means they can operate in either mode.

Endianness also affects packed structures and protocol headers. If developers ignore it, communication between devices may fail due to incorrect byte interpretation.

A watchdog timer (WDT) is a hardware timer used to automatically reset a microcontroller if the software becomes unresponsive. It is a safety mechanism designed to recover systems from hangs, infinite loops, or unexpected deadlocks.

The basic idea is simple:
The program must periodically “kick” or “refresh” the watchdog before a timeout expires. If it fails to do so, the watchdog assumes the system has crashed and forces a reset.

Typical implementation steps in Embedded C:

1. Configure the watchdog timeout during system initialization.
2. Periodically refresh the watchdog inside the main loop.
3. If the refresh does not occur in time, the MCU resets automatically.

Example pattern:

WDT->CTRL = WDT_ENABLE | WDT_TIMEOUT_2S;

while (1) {
   do_work();
   WDT->REFRESH = 0xAA55;   // Kick the watchdog
}

If do_work() gets stuck and never returns, the watchdog expires and resets the system. After reset, execution starts again from the reset vector.

An advanced variation is the windowed watchdog, where the refresh must occur within a specific time window, not too early and not too late. This prevents faulty code from blindly refreshing the watchdog inside a tight loop.

Watchdog timers are critical in safety-critical systems such as automotive (ISO 26262) and industrial automation (IEC 61508), where automatic recovery without human intervention is mandatory.

In interviews, emphasize that the watchdog should be refreshed only after successful execution of critical tasks, not blindly at fixed intervals.

Memory-mapped I/O is a technique where hardware registers are assigned fixed memory addresses. These addresses can be accessed just like normal variables in C.

For example:

#define PORTB (*(volatile unsigned char*)0x25)

Here, address 0x25 is mapped to a hardware register. Writing to PORTB directly controls the hardware.

The volatile keyword is crucial because hardware registers may change independently of program execution. Without volatile, the compiler might optimize away necessary reads or writes.

Another common approach is mapping registers using structures:

typedef struct {
   volatile uint32_t CR;
   volatile uint32_t SR;
   volatile uint32_t DR;
} UART_TypeDef;

#define UART1 ((UART_TypeDef*)0x40011000)

Now you can access registers as:

UART1->CR = 0x01;

This method improves readability and aligns with modern firmware development practices.

It is also important to understand the difference between memory-mapped I/O and port-mapped I/O. In memory-mapped I/O, registers share the same address space as RAM. In port-mapped I/O (used in some x86 systems), special CPU instructions like IN and OUT are used instead of direct memory access.

Memory-mapped I/O is foundational in embedded systems because it enables direct hardware control through C code.

Bit manipulation is fundamental in embedded development. Hardware peripherals are controlled by setting or clearing specific bits inside control registers.

Common macros used in firmware:

#define SET_BIT(REG, BIT)     ((REG) |= (1U << (BIT)))
#define CLEAR_BIT(REG, BIT)   ((REG) &= ~(1U << (BIT)))
#define TOGGLE_BIT(REG, BIT)  ((REG) ^= (1U << (BIT)))
#define CHECK_BIT(REG, BIT)   ((REG) & (1U << (BIT)))

Example usage:

SET_BIT(PORTB, 3);   // Set bit 3 (e.g., turn on LED)
CLEAR_BIT(PORTB, 3); // Clear bit 3
TOGGLE_BIT(PORTB, 3);

Parentheses are critical in macros to prevent unexpected behavior due to operator precedence.

For multi-bit fields, masks are used:

#define MASK 0x0F
REG = (REG & ~MASK) | (value & MASK);

One important embedded concept is the read-modify-write hazard. If an interrupt modifies the same register during this process, unexpected behavior can occur. In such cases, atomic operations or interrupt disabling may be required.

Understanding register-level bit manipulation is essential in embedded c interview questions and answers, because almost every peripheral configuration relies on it.

An Interrupt Service Routine (ISR) is a special function that executes automatically when a hardware or software interrupt occurs. Interrupts may be triggered by events such as timer overflow, UART data reception, or an external pin change.

The syntax varies by compiler. For example, in AVR-GCC:

ISR(TIMER1_OVF_vect) {
   // ISR code
}

When an interrupt occurs, the processor temporarily pauses the main program, executes the ISR, and then resumes execution.

Best practices for writing ISRs are critical in microcontroller c interview questions:

• Keep ISRs short. Set a flag and return; process logic in the main loop.
• Avoid dynamic memory allocation (malloc/free) inside ISR.
• Do not use non-reentrant functions like printf.
• Declare shared variables as volatile.
• Clear the interrupt flag before exiting (if required).
• Avoid large stack usage inside ISR.
• Be cautious with interrupt nesting and priority levels.

Example pattern:

volatile int timerFlag = 0;

ISR(TIMER1_OVF_vect) {
   timerFlag = 1;
}

int main() {
   while (1) {
       if (timerFlag) {
           timerFlag = 0;
           // Process event
       }
   }
}

This pattern ensures minimal ISR latency and system stability.

A microcontroller (MCU) is a complete system on a single chip. It includes a CPU, RAM, ROM/Flash, and peripherals like GPIO, ADC, UART, SPI, and timers. Examples include ATmega328P (Arduino Uno) and STM32 series.

A microprocessor (MPU), on the other hand, contains only the CPU. It requires external RAM, storage, and peripheral chips to function. Examples include Intel Core processors or ARM Cortex-A series used in systems running Linux or Android.

With a microcontroller:

• Memory is limited (e.g., 32KB Flash, 2KB RAM).
• Code must be size-optimized.
• Most systems run without an operating system (bare-metal).
• Developers directly access hardware registers.
• Startup code and linker scripts are crucial.

With a microprocessor:

• External memory and storage are used.
• Operating systems are common.
• Abstraction layers exist between hardware and application code.

In embedded C programming, every design decision, stack size, memory usage, peripheral configuration, depends on whether you are working on an MCU or MPU.