C Interview Questions

C Interview Questions for Intermediate 

13. Specify different types of decision control statements.

In C programming, control statements manage the flow of execution based on conditions. The main types include:

• If-else: Executes code based on a true or false condition.
   
• Else-if: Checks multiple conditions in sequence.
   
• Nested if-else: Uses if-else within another if-else for complex decision-making.
   
• Switch: Selects one of many code blocks to execute based on a specific value.
   

These control structures allow for dynamic decision-making in programs.

14. What is an r-value and l-value?

r-value:

• Refers to a data value stored at a specific memory address.
   
• Can only appear on the right side of an assignment operator (=).
   
• Cannot have a value assigned to it.

l-value:

• Represents a memory location identifying an object.
   
• It can appear on both the left and right sides of an assignment operator (=).
   
• Often used as an identifier.

15. What is call by reference in functions?

• Call by Reference passes the addresses of the actual parameters to the function.
   
• Changes made to the formal parameters affect the actual parameters.
   
• Both the formal and actual parameters share the same memory location.
   
• This allows direct modification of the actual parameters within the function.

16. What are goto statements in C? Should we use them?

Ans: The goto statement is a jump statement, often known as an unconditional jump statement. We can move program control to the designated label using the goto statement. You can jump from one label to another within a function using the goto statement. 

The syntax of goto statements:

goto label;
... .. ...
... .. ...
label: 
/* do something */

Goto statements are rarely helpful; you can write any C program without them. You can use the goto statement if it simplifies your code. Goto statements are helpful in some cases, for example, to break out nested loops. 

17. What are static variables in C?

Ans: Static variables can retain their actual values even after they quit their scope. You can declare static variables in C using the static keyword. When a function call, where the variable was defined, is completed, an auto or normal variable is destroyed. When the program runs, a static variable is still in memory for various function calls.

In other words, while a static variable's value is retained between function calls, the "static" keyword can only initialise a variable once.

Here is an example of a static variable in C:

#include<stdio.h>
int fun1()
{
  static int count = 0;
  count++;
  return count;
}


int fun2()
{
  int count = 0;
  count++;
  return count;
}
  
int main()
{
  printf("Example of static variable\n");
  printf("%d \n", fun1());
  printf("%d \n", fun1());
  
  printf("Example of auto variable\n");
  printf("%d \n", fun2());
  printf("%d", fun2());
  
  return 0;
}

Output

Example of static variable

1 

2 

Example of auto variable

1 

1

18. What is the difference between continue and break statements in C?

Ans: The difference between continue and break statements are as follows:

19. What is the difference between pre-increment and post-increment in C?

Ans: The increment operator(++) in C is used to increase the value of a variable by one. There are two types of increment operators:

• Pre-increment operator.
   
• Post-increment operator.
   

The difference between pre-increment and post-increment is as follows:

Example of pre-increment:

#include<stdio.h>
int main(){
	int x = 4;

	//pre-increment operator will increase the value of 'x' then assign
	//it to 'y'.
	int y = ++x;
	printf("x = %d\ny = %d\n", x,y);
	return 0;
}

Output:

x = 5

y = 5

Example of post-increment:

#include<stdio.h>
int main(){
	int x = 4;
	//post-increment operator will assign the value of 'x' to y then
	//increment it.
	int y = x++;
	printf("x = %d\ny = %d\n", x,y);
	return 0;
}

Output:

x = 5

y = 4

20. What do you mean by typedef in C?

Ans:  The typedef keyword is used in C language to give current variables in a programme some meaningful names. Typedef is used with user-defined datatypes when it becomes tricky to use the names of datatypes in programmes.

In simple terms, we can state that the typedef keyword is used to change the name of a variable that already exists. It functions identically to create a command alias.

The syntax of typedef in C is as follows:

typedef <existing_variable_name> <alias_name>

Here is a simple example of the typedef keyword in C:

#include <stdio.h>  
int main()  
{  
	typedef unsigned int ui;  
	ui x,y;  
	x=4;  
	y=5;  
	printf("The value of x is %d",x);  
	printf("\n The value of y is %d",y);  
	return 0;  
}

Output:

The value of x is 4

The value of y is 5

21. What is the difference between call by value and call by reference?

Ans: The difference between call by value and call by reference is as follows:

Call by value:

• In call by value, we pass variables' values to functions when we call them. 
   
• In call by value method:
  • Actual parameter values are copied to the formal parameters of the function.
     
  • Both types of parameters are stored in separate parts of memory.
     
• The values of the actual variables in the calling function are unaffected by changes made to the call function's formal variables.
   

Example of call by value method:

#include <stdio.h>

void swap_function(int a, int b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
    printf("a=%d b=%d\n", a, b);
}


// Main function
int main()
{
    int x = 5, y = 6;
    swap_function(x, y);
    printf("x=%d y=%d\n", x, y);
    return 0;
}

Output:

a=6 b=5

x=5 y=6

Call by reference:

• In call by value, instead of passing variables' values,  we pass variables' addresses to functions when we call them. 
   
• In the call-by-reference method, both types of parameters refer to the same memory location.
   
• The values of the actual variables in the calling function are affected by changes made to the call function's formal variables.
   

Example of call by reference method:

#include <stdio.h>
void swap_function(int*a, int*b)
{
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
    printf("a=%d b=%d\n", *a, *b);
}

// Main function
int main()
{
    int x = 5, y = 6;
    swap_function(&x, &y);

    printf("x=%d y=%d\n", x, y);
    return 0;
}

Output:

a=6 b=5

x=6 y=5

22. What is the difference between getc(), getch(), getche(), and getchar()?

Ans: The key difference between getc(), getch(), getche(), and getchar() is as follows:

• getc(): The getc() function reads one character from any input.
  Successful Operation: Returns the ASCII value of that character.
  Failure: EOF(End of file).
  The syntax of the getc() method is as follows:
   

int getc(FILE *stream);

• getch(): It also reads one character from any input. It doesn’t use any buffer. Therefore, the entered character returns immediately.
  The syntax of the getch() method is as follows:
   

int getch();

• getche(): The conio.h file contains the getche(), another non-standard type of function. The getche() can read one character from any available keyboard. It uses a buffer but also reflects the output immediately on the screen.
  The syntax of the getch() method is as follows:
   

int getche(void);

• getchar(): The getchar() function can only read from the standard input. The getchar() method is similar to the getc(stdin).
  The syntax of the getchar() method is as follows:
   

int getchar(void);

Here are some advanced-level interview questions for your interview preparation.

23. What is the difference between a union and a structure in C?

Ans: The differences between a union and a structure are as follows:

24. Can we convert a number to a string in C?

Ans: Yes, you can convert a number to a string in C. The sprintf() function is used to perform that conversion. The syntax of the sprintf() function is as follows:

int sprintf(char* str, const char* format_string, argument1, argument2,..)

Here is the code showing the sprintf() function.

#include<stdio.h>
int main()
{
    char str[20];
    float number = 22.32;
    
    sprintf(str, "%f", number);
    printf("\n The resultant string for the given number is %s", number);
    puts(str);
    
    return 0;
}

Output:

The resultant string for the given number is 22.320000

25. How to convert a string to a number in C?

Ans: You can convert a string to a number in C using the atoi() function. The syntax of the atoi() function is as follows:

int atoi(const char* string);

Input: 

String of characters.

Return value: 

Numeric value of desired return type.

At the first character that it cannot identify as a component of a number, the function stops reading the input string. For example, the NULL character at the end of a string.

Here is the code showing the working of atoi() function.

#include <stdlib.h>
#include <stdio.h>
int main(void)
{
    int num;  
    char str1[20] = "22345343";  
    num = atoi(str1);  
    printf("The string value is: %s\n", str1); 
    printf("The resultant integer value is: %d\n", num); 
    
    printf("-----------------------------------------------\n");
    
    char str2[20] = "Coding Ninjas"; 
    num = atoi(str2); 
    printf("The string value is: %s\n", str2); 
    printf("The resultant integer value is: %d\n", num); 
 
}

Output:

The string value is: 22345343
The resultant integer value is: 22345343
-----------------------------------------------
The string value is: Coding Ninjas
The resultant integer value is: 0

C Interview Questions for Experienced 

26. Explain Dynamic Memory Allocations.

Ans: Dynamic Memory Allocation(DMA) is one of the most important features of C. It enables the user to allocate memory locations at runtime. An example of DMA is the memory allocation of a linked list. Using the DMA property, one can increase the memory allocation during execution.

The <stdlib.h> header file is used for DMA in C language. The four predefined library functions used for DMA in C are as follows:

• malloc(): You can allocate a single block of the specified memory using malloc().
   
• calloc(): You can allocate a number of required memory blocks(let’s suppose N) using calloc().
   
• free(): One can use the free() method to deallocate the memory blocks after program execution.
   
• realloc(): One can reallocate the memory that is previously allocated by malloc() or calloc() using the realloc().
   

Here is an example showing DMA:

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

int main() {
  int n;
  // ptr will point to the base address
  int * p;

  // User input
  printf("Enter your number of elements:");
  scanf("%d", & n);

  // DMA using malloc()
  p = (int * ) malloc(n * sizeof(int));

  // Checking for memory allocation
  if (p == NULL) {
    printf("Error: Unable to allocate specified memory.\n");
    exit(0);
  } 
  else {
    // successful operation
    printf("Memory successfully allocated using malloc.\n");
    printf("Entered number of elements by you: %d\n", n);
    for (int i = 0; i < n; i++) {
      p[i] = i + 1;
    }
    // Print the elements of the array
    printf("The array elements are ");
    for (int i = 0; i < n; i++) {
      printf("%d, ", p[i]);
    }
  }
  free(p);
  return 0;
}

Output:

Enter your number of elements:7

Memory successfully allocated using malloc.

Entered number of elements by you: 7

The array elements are 1, 2, 3, 4, 5, 6, 7,

27. What is a memory leak in C?

Ans: Suppose you have allocated the memory dynamically and forget to free that memory. The program no longer uses that memory, but the space remains occupied. This will result in a memory leak problem. It is extremely harmful when the servers and daemons are included in the program.

Some of the important causes of memory leaks are as follows:

a. When we don’t free the memory.
 

b. If the pointer is given a distinct value before being freed.
See the code snippet below:

// DMA 
int* p = (int*)malloc(sizeof int);


// Before executing the free function, assign null to the pointer.
p = NULL;
//Results in a memory leak.

c. When the pointer goes out of scope.

Void function(){
int* p = (int*)malloc(sizeof int);
//Once control exits the scope, the local pointer becomes invalid.
}
//Results in a memory leak.

28. What is a volatile qualifier in C?

Ans: The volatile qualifier is applied when declaring a variable in a C program. 

The volatile keyword prevents the compiler's optimisations from being applied to objects that are marked as volatile. It informs the compiler that the value declared as volatile is mutable.

When an object is marked as "volatile," memory registers rather than cache variables are used to retrieve its value. Any object marked as volatile is vulnerable to an abrupt change in value from the compiler, even if there hasn't been any work done on that object within the program.

Volatile qualifiers are generally used in multithreaded programs. Some important features of volatile qualifiers are as follows:

• The volatile keyword cannot revoke the memory designation.
   
• The sequence of assignments does not affect the value.
   
• The values in the register cannot be cached.

29. What is the difference between malloc() and calloc()?

Ans: Both malloc() and calloc() are used in Direct Memory Allocation. The difference between malloc() and calloc() are as follows:

30. What is printed by the following C program?

#include <stdio.h>
int func(int, int*, int**);
  
void main()
{
   int p, *q, **r;
   p = 5; 
   q = &p;
   r = &q;  
   printf( "%d", func(p,q,r));
   getchar();
}


int func(int x, int *py, int **pz)
{ 
  int y, z; 
  **pz += 1;  
   z  = **pz; 
  *py += 2; 
   y = *py;
   x += 3;
   return x + y + z;
}

Ans: The output of the above code is 22.

Explanation: The code  **pz += 1 sets the value of p to 6 because x(dummy variable) is a copy of p and has a distinct address from p. The value x is unaffected by this change.

When we perform z  = **pz, the value of z becomes 6. 

The code  *py += 2 sets the value of p as 8( 6 + 2).

Using y = *py, the value of y becomes 8.

Now, by using the code x += 3, the value of x is incremented by 3, resulting in a value of 8.

Finally, x+y+z will be 8+8+6, which is equal to 22. Therefore the output value of the above-mentioned code is 22.

31. Differentiate between the macros and the function

32. Discuss the concept of function pointers as callback functions in C.

Ans: Function pointers can be used as callback functions in C to enable dynamic behavior and function invocation. By passing a function pointer as an argument to another function, that function can then call the callback function at a later time, allowing for customisable and flexible program behaviour.

33. Discuss the differences between deep copy and shallow copy in C.

Ans: A Deep copy in C ensures that each object has its own independent memory by making a distinct copy of dynamically allocated memory. In contrast, a shallow copy makes a fresh reference to the existing memory, allowing many objects to share the same memory. A deep copy needs to be explicitly implemented, but a shallow copy can be accomplished with a straightforward assignment.

34. Explain the concept of function pointer arrays in C.

Ans: Function addresses are kept in function pointer arrays. They enable the dynamic selection and invocation of functions based on runtime environments. Different functions can be called by indexing the array with the proper values, allowing for flexible algorithmic choices and program behaviour.

35. Explain the concept of multi-threading in C and discuss the associated challenges.

Ans: Multi-threading in C involves creating and managing multiple concurrent threads of execution within a program. It allows for parallelism and improved performance. However, challenges such as thread synchronisation, shared resource access, and race conditions need to be carefully handled to ensure thread safety and avoid unexpected behaviour.

36. What are a near pointer and a far pointer in C?

Ans: Near pointer in C is a pointer that works within the range of 64Kb data segment of memory. This means that the near pointer is used to store the 16-bit addresses; they can only reach the memory addresses within the ongoing segment on a 16-bit machine. The size of the near pointer is 2 bytes.

A far pointer in C is a 32-bit pointer that can access information that is outside the computer memory in a given segment. The compiler creates a segment register for the segment address and another register for the offset within the current segment. In the far pointer, the segment part cannot be changed as incrementing/decrementing; it only changes the offer but not the segment address. The size of the far pointer is 4 bytes.

Also read reverse a number.

Frequently Asked Questions

What is C programming language used for?

C programming is widely used for developing system software, application software, and embedded systems. It is pretty straightforward, and provides a powerful interface for programming languages.

Why C is called middle-level language?

C is called middle-level language as it actually binds the gap between a machine-level language and a high-level language. A programmer can use C language for Application programming as well as for System Programming.

How to prepare for C language interview?

Review the foundational ideas, do coding activities, and respond to sample questions to prepare for a C language interview. Revisit concepts like pointers, arrays, memory management, and data structures. Additionally, become acquainted with standard C programming idioms and good practices.

Why is C known as a mother language?

C is known as the "mother language" since it served as the model for the creation of numerous other programming languages. It is effective and versatile because it offers a straightforward syntax, low-level memory access, and a small runtime environment.

Conclusion

In this article, we have discussed the top 30 most asked C interview Questions. We looked at questions of different categories: beginner, intermediate and advanced. We also looked at some frequently asked questions. 

Recommended Readings:

• LWC Interview Questions
• Web API Interview Questions
• Informatica Interview Questions
• Javascript interview questions
•  Wordpress Interview Questions