1. Why is C called a mid-level programming language?

C has characteristics of both assembly-level i.e. low-level and higher-level languages.

So as a result, C is commonly called a middle-level language. Using C, a user can
write an operating system as well as create a menu-driven consumer billing system.

2. What are the features of the C language?

Some features of the C language are-

1. It is Simple And Efficient.

2. C language is portable or Machine Independent.
3. C is a mid-level Programming Language.
4. It is a structured Programming Language.
5. It has a function-rich library.
6. Dynamic Memory Management.
7. C is super fast.
8. We can use pointers in C.
9. It is extensible.

3. What is a token?

The individual elements of a program are called Tokens. There are following 6 types
of tokens are available in C:

 Identifiers
 Keywords
 Constants
 Operators
 Special Characters
 Strings

You can download a PDF version of C Interview Questions.

Download PDF

4. What is the use of printf() and scanf() functions? Also explain

format specifiers?

 printf() is used to print the output on the display.

 scanf() is used to read formatted data from the keyboard.

Some datatype format specifiers for both printing and scanning purposes are as
follows:

 %d: It's a datatype format specifier for printing and scanning an integer value.
 %s: It's a datatype format specifier for printing and scanning a string.
 %c: It's a datatype format specifier for displaying and scanning a character value.
 %f: The datatype format specifier %f is used to display and scan a float value.

5. What's the value of the expression 5["abxdef"]?

The answer is 'f'.

Explanation: The string mentioned "abxdef" is an array, and the expression is equal
to "abxdef"[5]. Why is the inside-out expression equivalent? Because a[b] is
equivalent to *(a + b) which is equivalent to *(b + a) which is equivalent to b[a].

6. What is a built-in function in C?

The most commonly used built-in functions in C are scanf(), printf(), strcpy, strlwr,
strcmp, strlen, strcat, and many more.

Built-function is also known as library functions that are provided by the system to
make the life of a developer easy by assisting them to do certain commonly used
predefined tasks. For example, if you need to print output or your program into the
terminal, we use printf() in C.

7. What is a Preprocessor?

A preprocessor is a software program that processes a source file before sending it

to be compiled. Inclusion of header files, macro expansions, conditional compilation,
and line control are all possible with the preprocessor.

8. In C, What is the #line used for?

In C, #line is used as a preprocessor to re-set the line number in the code, which
takes a parameter as line number. Here is an example for the same.

#include <stdio.h> /*line 1*/

int main(){ /*li

 printf("Hello world\n"); /*line
5*/
//print current line /*line
6*/
printf("Line: %d\n",__LINE__); /*line 7*/
//reset the line number by 36 /*line 8*/
#line 36 /*reseting*/
//print current line /*line
36*/
printf("Line: %d\n",__LINE__); /*line 37*/
printf("Bye bye!!!\n"); /*line 39*/

return 0; /*li
}

9. How can a string be converted to a number?

The function takes the string as an input that needs to be converted to an integer.

int atoi(const char *string)

Return Value:

 On successful conversion, it returns the desired integer value

 If the string starts with alpha-numeric char or only contains alpha-num char, 0 is
returned.
 In case string starts with numeric character but is followed by alpha-num char, the
string is converted to integer till the first occurrence of alphanumeric char.

Converting String to Number

10. How can a number be converted to a string?

The function takes a pointer to an array of char elements that need to be converted,
and a format string needs to be written in a buffer as a string

int sprintf(char *str, const char *format, ...)

The output after running the above code:

Output: Value of Pi = 3.141593

11. What is recursion in C?

When a function in C calls a copy of itself, this is known as recursion. To put it

another way, when a function calls itself, this technique is called Recursion. Also, this
function is known as recursive function.
Syntax of Recursive Function:

void do_recursion()
{
... .. ...
do_recursion();
... .. ...]
}
int main()
{
... .. ...
do_recursion();
... .. ...
}

12. Why doesn‟t C support function overloading?

After you compile the C source, the symbol names need to be intact in the object
code. If we introduce function overloading in our source, we should also provide
name mangling as a preventive measure to avoid function name clashes. Also, as C is
not a strictly typed language many things(ex: data types) are convertible to each
other in C. Therefore, the complexity of overload resolution can introduce confusion
in a language such as C.

When you compile a C source, symbol names will remain intact. If you introduce
function overloading, you should provide a name mangling technique to prevent
name clashes. Consequently, like C++, you'll have machine-generated symbol names
in the compiled binary.

Additionally, C does not feature strict typing. Many things are implicitly convertible
to each other in C. The complexity of overload resolution rules could introduce
confusion in such kind of language

13. What is the difference between global int and static int
declaration?

The difference between this is in scope. A truly global variable has a global scope and
is visible everywhere in your program.

#include <stdio.h>

int my_global_var = 0;

int
main(void)

{
printf("%d\n", my_global_var);
return 0;
}
 global_temp is a global variable that is visible to everything in your program,
although to make it visible in other modules, you'd need an ”extern int global_temp;
” in other source files if you have a multi-file project.

A static variable has a local scope but its variables are not allocated in the stack
segment of the memory. It can have less than global scope, although - like global
variables - it resides in the .bss segment of your compiled binary.

#include <stdio.h>

int
myfunc(int val)

{
static int my_static_var = 0;

my_static_var += val;
return my_static_var;
}

int
main(void)

{
int myval;

myval = myfunc(1);
printf("first call %d\n", myval);

myval = myfunc(10);

printf("second call %d\n", myval);

return 0;
}

14.

14. What is a pointer in C?

A pointer is a variable that stores or points to another variable's address. The value of
a variable is stored in a normal variable, whereas the address of a variable is stored in
a pointer variable.

15. Difference between const char* p and char const* p?

 const char* p is a pointer to a const char.

 char const* p is a pointer to a char const.

Since const char and char const are the same, it's the same.
16. What is pointer to pointer in C?

In C, a pointer can also be used to store the address of another pointer. A double
pointer or pointer to pointer is such a pointer. The address of a variable is stored in
the first pointer, whereas the address of the first pointer is stored in the second
pointer.

The syntax of declaring a double pointer is given below:

int **p; // pointer to a pointer which is pointing to an integer

17. Why n++ executes faster than n+1 ?

n++ being a unary operation, it just needs one variable. Whereas, n = n + 1 is a

binary operation that adds overhead to take more time (also binary operation: n +=
1). However, in modern platforms, it depends on few things such as processor
architecture, C compiler, usage in your code, and other factors such as hardware
problems.

While in the modern compiler even if you write n = n + 1 it will get converted into
n++ when it goes into the optimized binary, and it will be equivalently efficient.

18. What is typecasting in C?

 Typecasting is the process to convert a variable from one datatype to another. If we
want to store the large type value to an int type, then we will convert the data type
into another data type explicitly.

Syntax: (data_type)expression;

For Example:

int x;
for(x=97; x<=122; x++)
{
printf("%c", (char)x); /*Explicit casting from int to char*/
}

19. What are the advantages of Macro over function?

Macro on a high-level copy-paste, its definitions to places wherever it is called. Due

to which it saves a lot of time, as no time is spent while passing the control to a new
function and the control is always with the callee function. However, one downside is
the size of the compiled binary is large but once compiled the program
comparatively runs faster.

20. What are Enumerations?

Enumeration, also known as Enum in C, is a user-defined data type. It consists of

constant integrals or integers that have names assigned to them by the user. Because
the integer values are named with enum in C, the whole program is simple to learn,
understand, and maintain by the same or even different programmer.

21. When should we use the register storage specifier?

If a variable is used frequently, it should be declared with the register storage

specifier, and the compiler may allocate a CPU register for its storage to speed up
variable lookup.

C Intermediate Interview Questions

22. Specify different types of decision control statements?

All statements written in a program are executed from top to bottom one by one.
Control statements are used to execute/transfer the control from one part of the
program to another depending on the condition.

 If-else statement.
o normal if-else statement.
o Else-if statement
o nested if-else statement.
 Switch statement.

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

 The term "r-value" refers to a data value stored in memory at a given address. An r-value is
an expression that cannot have a value assigned to it, hence it can only exist on the right side
of an assignment operator(=).
 The term "l-value" refers to a memory location that is used to identify an object. The l-value
can be found on either the left or right side of an assignment operator(=). l-value is
frequently used as an identifier.

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

calloc() and malloc() are memory dynamic memory allocating functions. The main
difference is that malloc() only takes one argument, which is the number of bytes, but
calloc() takes two arguments, which are the number of blocks and the size of each
block.

25. What is the difference between struct and union in C?

A struct is a group of complex data structures stored in a block of memory where

each member on the block gets a separate memory location to make them
accessible at once

Whereas in the union, all the member variables are stored at the same location on
the memory as a result to which while assigning a value to a member variable will
change the value of all other members.

/* struct & union definations*/

struct bar {
int a; // we can use a & b both simultaneously
char b;
} bar;

union foo {
int a; // we can't use both a and b simultaneously
char b;
} foo;

/* using struc and union variables*/

struct bar y;
y.a = 3; // OK to use
y.b = 'c'; // OK to use

union foo x;
x.a = 3; // OK
x.b = 'c'; // NOl this affects the value of x.a!
26. What is call by reference in functions?

When we caller function makes a function call bypassing the addresses of actual
parameters being passed, then this is called call by reference. In incall by reference,
the operation performed on formal parameters affects the value of actual parameters
because all the operations performed on the value stored in the address of actual
parameters.

27. What is pass by reference in functions?

In Pass by reference, the callee receives the address and makes a copy of the address
of an argument into the formal parameter. Callee function uses the address to access
the actual argument (to do some manipulation). If the callee function changes the
value addressed at the passed address it will be visible to the caller function as well.

Pass By Reference

28. What is a memory leak? How to avoid it?

When we assign a variable it takes space of our RAM (either heap or RAM)dependent
on the size of data type, however, if a programmer uses a memory available on the
heap and forgets to a delta it, at some point all the memory available on the ram will
be occupied with no memory left this can lead to a memory leak.

int main()
{
char * ptr = malloc(sizeof(int));

/* Do some work */
/*Not freeing the allocated memory*/
return 0;
}

To avoid memory leaks, you can trace all your memory allocations and think forward,
where you want to destroy (in a good sense) that memory and place delete there.
Another way is to use C++ smart pointer in C linking it to GNU compilers.

29. What is Dynamic memory allocation in C? Name the dynamic

allocation functions.

C is a language known for its low-level control over the memory allocation of
variables in DMA there are two major standard library malloc() and free. The malloc()
function takes a single input parameter which tells the size of the memory requested
It returns a pointer to the allocated memory. If the allocation fails, it returns NULL.
The prototype for the standard library function is like this:
 void *malloc(size_t size);
The free() function takes the pointer returned by malloc() and de-allocates the
memory. No indication of success or failure is returned. The function prototype is like
this:

void free(void *pointer);

There are 4 library functions provided by C defined under <stdlib.h> header file to
facilitate dynamic memory allocation in C programming. They are:

 malloc()
 calloc()
 free()
 realloc()

30. What is typedef?

typedef is a C keyword, used to define alias/synonyms for an existing type in C

language. In most cases, we use typedef's to simplify the existing type declaration
syntax. Or to provide specific descriptive names to a type.

typedef <existing-type> <new-type-identifiers>;

typedef provides an alias name to the existing complex type definition. With typedef,
you can simply create an alias for any type. Whether it is a simple integer to complex
function pointer or structure declaration, typedef will shorten your code.

31. Why is it usually a bad idea to use gets()? Suggest a workaround.

The standard input library gets() reads user input till it encounters a new line
character. However, it does not check on the size of the variable being provided by
the user is under the maximum size of the data type which makes the system
vulnerable to buffer overflow and the input being written into memory where it isn’t
supposed to.

We, therefore, use gets() to achieve the same with a restricted range of input

Bonus: It remained an official part of the language up to the 1999 ISO C standard,
but it was officially removed by the 2011 standard. Most C implementations still
support it, but at least GCC issues a warning for any code that uses it.

32. What is the difference between #include "..." and #include <...>?

In practice, the difference is in the location where the preprocessor searches for the
included file.
For #include <filename> the C preprocessor looks for the filename in the predefined
list of system directories first and then to the directories told by the user(we can use
-I option to add directories to the mentioned predefined list).

For #include "filename" the preprocessor searches first in the same directory as the
file containing the directive, and then follows the search path used for the #include
<filename> form. This method is normally used to include programmer-defined
header files.

33. What are dangling pointers? How are dangling pointers different
from memory leaks?

The dangling pointer points to a memory that has already been freed. The storage is
no longer allocated. Trying to access it might cause a Segmentation fault. A common
way to end up with a dangling pointer:

#include<stdio.h>
#include<string.h>

char *func()
{
char str[10];
strcpy(str,"Hello!");
return(str);
}

You are returning an address that was a local variable, which would have gone out of
scope by the time control was returned to the calling function. (Undefined behavior)

*c = malloc(5izeof(int));
free(c);
*c = 3; //writing to freed location!

In the figure shown above writing to a memory that has been freed is an example of
the dangling pointer, which makes the program crash.

A memory leak is something where the memory allocated is not freed which causes
the program to use an undefined amount of memory from the ram making it
unavailable for every other running program(or daemon) which causes the programs
to crash. There are various tools like O profile testing which is useful to detect
memory leaks on your programs.

void function(){
char *leak = malloc (10); //leak assigned but not freed
}

34. What is the difference between „g‟ and “g” in C?

 In C double-quotes variables are identified as a string whereas single-quoted
variables are identified as the character. Another major difference being the string
(double-quoted) variables end with a null terminator that makes it a 2 character
array.

35. What is a near pointer and a far pointer in C?

 Near Pointer: In general, the near pointer can be considered because it is used to hold the
address, which has a maximum size of just 16 bits. We can't store an address with a size
larger than 16 bits using the near pointer. All other smaller addresses that are within the 16-
bit limit, on the other hand, can be stored. Because we can only access 64kb of data at a
time, you might assume the 16 bits are insufficient. As a result, it is regarded as one of the
near-pointer's biggest drawbacks, which is why it is no longer commonly used.
 Far Pointer: A far pointer is considered a pointer of size 32 bits. It can, however, use the
current segment to access information stored outside the computer's memory. Although, in
order to use this type of pointer, we usually need to allocate the sector register to store the
data address in the current segment.

36. Which structure is used to link the program and the operating
system?

The file structure is used to link the operating system and a program. The header file
"stdio.h" (standard input/output header file) defines the file. It contains information
about the file being used like its current size and its memory location. It contains a
character pointer that points to the character which is currently being opened. When
you open a file, it establishes a link between the program and the operating system
about which file is to be accessed.

37. Suppose a global variable and local variable have the same name.
Is it possible to access a global variable from a block where local
variables are defined?

No. This isn’t possible in C. It’s always the most local variable that gets preference.

38. Which is better #define or enum?

 If we let it, the compiler can build enum values automatically. However, each of the defined
values must be given separately.
 Because macros are preprocessors, unlike enums, which are compile-time entities, the source
code is unaware of these macros. So, if we use a debugger to debug the code, the enum is
superior.
 Some compilers will give a warning if we use enum values in a switch and the default case is
missing.
 Enum always generates int-type identifiers. The macro, on the other hand, allowed us to pick
between various integral types.
 Unlike enum, the macro does not have a defined scope constraint.

C Interview Questions For Experienced

39. How can you remove duplicates in an array?

The following program will help you to remove duplicates from an array.

#include <stdio.h>
int main() {
int n, a[100], b[100], calc = 0, i, j,count;
printf("Enter no. of elements in array: ");
scanf("%d", &n);
printf("Enter %d integers: ", n);
for (i = 0; i < n; i++)
scanf("%d", &a[i]);

for (i = 0; i<n; i++) {

for (j = 0; j<calc; j++) {
if(a[i] == b[j])
break;
}
if (j== calc) {
b[calc] = a[i];
calc++;
}
}

printf("Array obtained after removing duplicate elements: ");

for (i = 0; i<calc; i++) {
printf("%d ", b[i]);
}
return 0;
}

40. Can we compile a program without a main() function?

Yes, we can compile a program without main() function Using Macro.

E.g.

#include<studio.h>
#define abc main
int abc ()
{
printf("Hello World ");
return 0;
}

41. Write a program to get the higher and lower nibble of a byte
without using shift operator?
#include<stdio.h>
struct full_byte
 {
char first : 4;
char second : 4;
};

union A
{
char x;
struct full_byte by;
};

main()
{
char c = 100;
union A a;
a.x = c;
printf("the two nibbles are: %d and %d\n", [Link], [Link]);
}

42. How do you override a defined macro?

To override a defined macro we can use #ifdef and #undef preprocessors as follows:

 #ifdef A
 #undef A
 #endif
 #define A 10

If macro A is defined, it will be undefined using undef and then defined again using
define.

43. Write a C program to check if it is a palindrome number or not

using a recursive method.
#include <stdio.h>
#include <conio.h>
int reverse(int num);
int isPalindrome(int num);
int main()
{
int num;
printf("Enter a number: ");
scanf("%d", &num);
if(isPalindrome(num) == 1)
{
printf("the given number is a palindrome");
}
else
{
printf("the given number is not a palindrome number");
}
return 0;
}

int isPalindrome(int num)

{
 if(num == reverse(num))
{
return 1;
}
return 0;
}
int reverse(int num)
{
int rem;
static int sum=0;
if(num!=0){
rem=num%10;
sum=sum*10+rem;
reverse(num/10);
}
else
return sum;
return sum;
}

44. C program to check the given number format is in binary or not.

#include<stdio.h>
#include<conio.h>
int main() {
int j,num;
printf("Please enter a number :");
scanf("%d",&num);
while(num>0)
{
j=num%10;
if( j!=0 && j!=1 )
{
printf("num is not binary");
break;
}
num=num/10;
if(num==0)
{
printf("num is binary");
}
}
getch();
}

45. C Program to find a sum of digits of a number using recursion.

#include<stdio.h>
#include<conio.h>

int sumOfDigits(int num)

{
static int sum = 0;
int rem;
sum = sum + (num%10);
rem = num/10;
if(rem > 0)
{
sumOfDigits(rem);
 }
return sum;
}
int main() {
int j,num;
printf("Please enter a number :");
scanf("%d",&num);
printf("sum of digits of the number = %d ",sumOfDigits(num));
getch();
}

46. Can you tell me how to check whether a linked list is circular?

Single Linked List

Single Linked List

Circular Linked List

Circular linked list is a variation of a linked list where the last node is pointing to the
first node's information part. Therefore the last node does not point to null.

Algorithm to find whether the given linked list is circular

A very simple way to determine whether the linked list is circular or not

 Traverse the linked list

 Check if the node is pointing to the head.
 If yes then it is circular.

Let's look at the snippet where we code this algorithm.

Create a structure for a linked list

Declare
-Variable to store data of the node.
-Pointer variable of struct type to store the address of next node.

function of datatype tool isCircular(firstgode){

-Store the value of first node in temp variable and make it traverse all
nodes.
-temp-firstgode
-tempenext node pointed by temp(temp->next)
-run until temp is at null or firstNode

if (temp at null)
not circular and returns false
if (temp points first node)
return true as its circular.
}

function of datatype node newNode(data){

-To insert new nodes and link each one of them to the previous node by
storing the address of the new node to the previous one.
-Then make them point to NULL.
}

In int main function

-First insert nodes for circular linked list and check its nature by
calling isCircular function.
-Since it is true through if statement it prints "yes..
-Second insert a normal linked list and check its nature by calling
isCircular function. As its not circular it prints "no",

47. What is the use of a semicolon (;) at the end of every program
statement?

It is majorly related to how the compiler reads( or parses) the entire code and breaks
it into a set of instructions(or statements), to which semicolon in C acts as a
boundary between two sets of instructions.

48. How to call a function before main()?

To call a function before the main(), pragma startup directive should be used. E.g.-

#pragma startup fun

void fun()
{
printf("In fun\n");
}
main()
{
printf("In main\n");
}

The output of the above program will be -

In fun
In main

This pragma directive, on the other hand, is compiler-dependent. This is not

supported by gcc. As a result, it will ignore the startup directive and produce no
error. But the output, in that case, will be -

In main

49. Differentiate between the macros and the functions.

The differences between macros and functions can be explained as follows:

Macros Functions
Macros Functions

It is preprocessed rather than compiled. It is compiled not preprocessed.

It is preprocessed rather than compiled. Function checks for compilation errors.

Code length is increased. Code length remains the same.

Macros are faster in execution. Functions are a bit slower in execution.

Macros are useful when a small piece of code Functions are helpful when a large piece of
is used multiple times in a program. code is repeated a number of times.

50. Differentiate Source Codes from Object Codes

Source Code and Object Code Difference

The difference between the Source Code and Object Code is that Source Code is a
collection of computer instructions written using a human-readable programming
language while Object Code is a sequence of statements in machine language, and is
the output after the compiler or an assembler converts the Source Code.

The last point about Object Code is the way the changes are reflected. When the
Source Code is modified, each time the Source Code needs to be compiled to reflect
the changes in the Object Code.

51. What are header files and what are its uses in C programming?

Header Files in C

In C header files must have the extension as .h, which contains function definitions,
data type definitions, macro, etc. The header is useful to import the above definitions
to the source code using the #include directive. For example, if your source code
needs to take input from the user do some manipulation and print the output on the
terminal, it should have stdio.h file included as #include <stdio.h>, with which we can
take input using scanf() do some manipulation and print using printf().

52. When is the "void" keyword used in a function

The keyword “void” is a data type that literally represents no data at all. The most
obvious use of this is a function that returns nothing:

void PrintHello()
{
printf("Hello\n");
 return; // the function does "return", but no value is
returned
}

Here we’ve declared a function, and all functions have a return type. In this case,
we’ve said the return type is “void”, and that means, “no data at all” is returned.
The other use for the void keyword is a void pointer. A void pointer points to the
memory location where the data type is undefined at the time of variable definition.
Even you can define a function of return type void* or void pointer meaning “at
compile time we don’t know what it will return” Let’s see an example of that.

void MyMemCopy(void* dst, const void* src, int numBytes)

{
char* dst_c = reinterpret_cast<char*>(dst);
const char* src_c = reinterpret_cast<const char*>(src);
for (int i = 0; i < numBytes; ++i)
dst_c[i] = src_c[i];
}

53. What is dynamic data structure?

A dynamic data structure (DDS) refers to an organization or collection of data in

memory that has the flexibility to grow or shrink in size, enabling a programmer to
control exactly how much memory is utilized. Dynamic data structures change in size
by having unused memory allocated or de-allocated from the heap as needed.

Dynamic data structures play a key role in programming languages like C, C++, and
Java because they provide the programmer with the flexibility to adjust the memory
consumption of software programs.

54. Add Two Numbers Without Using the Addition Operator

For the sum of two numbers, we use the addition (+) operator. In these tricky C
programs, we will write a C program to add two numbers without using the addition
operator.

#include<stdio.h>
#include<stdlib.h>
int main()
{
int x, y;
printf("Enter two number: ");
scanf("%d %d",&x,&y);

// method 1
printf("%d\n", x-(-y));

// method 2
printf("%d\n", -(-x-y));

// method 3
printf("%d\n", abs(-x-y));
 // method 4
printf("%d", x-(~y)-1);

return 0;
}

55. Subtract Two Number Without Using Subtraction Operator

#include<stdio.h>
#include<stdlib.h>
int main()
{
int x, y;
printf("Enter two number: ");
scanf("%d %d",&x,&y);
printf("%d", x+(~y)+1);
return 0;
}

The bitwise complement operator is used in this program. The bitwise complement
of number ~y=-(y+1). So, expression will become x+(-(y+1))+1=x-y-1+1=x-y

56. Multiply an Integer Number by 2 Without Using Multiplication

Operator
#include<stdio.h>
int main()
{
int x;
printf("Enter a number: ");
scanf("%d",&x);
printf("%d", x<<1);
return 0;
}

The left shift operator shifts all bits towards the left by a certain number of specified
bits. The expression x<<1 always returns x*2. Note that the shift operator doesn’t
work on floating-point values.

For multiple of x by 4, use x<<2. Similarly x<<3 multiply x by 8. For multiple of the
number x by 2^n, use x<<n.

57. Check whether the number is EVEN or ODD, without using any
arithmetic or relational operators
#include<stdio.h>
int main()
{
int x;
printf("Enter a number: ");
scanf("%d", &x);
(x&1)?printf("Odd"):printf("Even");
 return 0;
}

The bitwise and(&) operator can be used to quickly check the number is odd or even.

58. Reverse the Linked List. Input: 1->2->3->4->5->NULL Output: 5-

>4->3->2->1->NULL

Assume that we have linked list 1 → 2 → 3 → Ø, we would like to change it to Ø ← 1

← 2 ← 3.

While you travel the linked list, change the current node's next pointer to point to its
previous element. reference to the previous nodes should be stored into a temp
variable as shown so that we don’t lose track of the swapped node. You also need
another pointer to store the next node before changing the reference. Also when we
are done return the new head of the reversed list.

/* Function to reverse the linked list */

static void reverse(struct Node** head_ref)
{
struct Node* prev = NULL;
struct Node* current = *head_ref;
struct Node* next;
while (current != NULL)
{
// store next
next = current->next;

// reverse curr node pointer

current->next = prev;

// move pointer one position ahead

prev = current;
current = next;
}
*head_ref = prev;
}

59. Check for Balanced Parentheses using Stack

 Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the
input string is valid.

An input string is valid if:

 Open brackets must be closed by the same type of brackets.

 Open brackets must be closed in the correct order.

Example 1:
Input: s = "()"
Output: true

Example 2:
Input: s = "()[]{}"
Output: true

Example 3:
Input: s = "(]"
Output: false

Below is the source code for C Program to Check for Balanced Parentheses using
Stack which is successfully compiled and run on Windows System to produce desired
output as shown below :

int check(char exp[] )

{
int i;
char temp;
for(i=0;i<strlen(exp);i++)
{
if(exp[i]=='(' || exp[i]=='{' || exp[i]=='[')
push(exp[i]);
if(exp[i]==')' || exp[i]=='}' || exp[i]==']')
if(top==-1) /*stack empty*/
{
 printf("Right parentheses are more than
left parentheses\n");
return 0;
}
else
{
temp=pop();
if(!match(temp, exp[i]))
{
printf("Mismatched parentheses are
: ");
printf("%c and %c\n",temp,exp[i]);
return 0;
}
}
}
if(top==-1) /*stack empty*/
{
printf("Balanced Parentheses\n");
return 1;
}
else
{
printf("Left parentheses more than right parentheses\n");
return 0;
}
}

60. Program to find n‟th Fibonacci number

Fibonacci sequence is characterized by the fact that every number after the first two
is the sum of the two preceding ones. For example, consider below sequence

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . .. and so on

Where in F{n} = F{n-1} + F{n-2} with base values F(0) = 0 and <code>F(1) = 1

Below is naive implementation for finding the nth member of the Fibonacci sequence

// Function to find the nth Fibonacci number

int fib(int n)
{
if (n <= 1) {
return n;
}

return fib(n - 1) + fib(n - 2);

}

int main()
 {
int n = 8;

printf("nth Fibonacci number is %d", fib(8));

return 0;
}

61. Write a program to find the node at which the intersection of two
singly linked lists begins.

Let's take an example of the following two linked lists which intersect at node c1.

Intersection of Two Linked List

Solution -

 Get count of the nodes in the first list, let count be c1.
 Get count of the nodes in the second list, let count be c2.
 Get the difference of counts d = abs(c1 – c2)
 Now traverse the bigger list from the first node till d nodes so that from here onwards both
the lists have an equal no of nodes
 Then we can traverse both the lists in parallel till we come across a common node. (Note that
getting a common node is done by comparing the address of the nodes)

// Function to get the intersection point

// of the given linked lists
int getIntersectionNode(Node* head1, Node* head2)
{
Node *curr1 = head1, *curr2 = head2;

// While both the pointers are not equal

while (curr1 != curr2) {

// If the first pointer is null then

// set it to point to the head of
// the second linked list
if (curr1 == NULL) {
curr1 = head2;
}
 // Else point it to the next node
else {
curr1 = curr1->next;
}

// If the second pointer is null then

// set it to point to the head of
// the first linked list
if (curr2 == NULL) {
curr2 = head1;
}

// Else point it to the next node

else {
curr2 = curr2->next;
}
}

// Return the intersection node

return curr1->data;
}

62. Merge Two sorted Linked List

Merge two sorted linked lists and return them as a sorted list. The list should be
made by splicing together the nodes of the first two lists.

Merging Two Sorted Linked List

NodePtr merge_sorted(NodePtr head1, NodePtr head2) {

// if both lists are empty then merged list is also empty

// if one of the lists is empty then other is the merged list
if (head1 == nullptr) {
 return head2;
} else if (head2 == nullptr) {
return head1;
}

NodePtr mergedHead = nullptr;

if (head1->data <= head2->data) {
mergedHead = head1;
head1 = head1->next;
} else {
mergedHead = head2;
head2 = head2->next;
}

NodePtr mergedTail = mergedHead;

while (head1 != nullptr && head2 != nullptr) {

NodePtr temp = nullptr;
if (head1->data <= head2->data) {
temp = head1;
head1 = head1->next;
} else {
temp = head2;
head2 = head2->next;
}

mergedTail->next = temp;
mergedTail = temp;
}

if (head1 != nullptr) {
mergedTail->next = head1;
} else if (head2 != nullptr) {
mergedTail->next = head2;
}

return mergedHead;
}

Runtime Complexity Linear, O(m + n) where m and n are lengths of both linked lists.

Memory Complexity Constant, O(1)

Maintain a head and a tail pointer on the merged linked list. Then choose the head
of the merged linked list by comparing the first node of both linked lists. For all
subsequent nodes in both lists, you choose the smaller current node and link it to the
tail of the merged list, moving the current pointer of that list one step forward.

You keep doing this while there are some remaining elements in both lists. If there
are still some elements in only one of the lists, you link this remaining list to the tail
of the merged list.
 Initially, the merged linked list is NULL. Compare the value of the first two nodes and
make the node with the smaller value the head node of the merged linked list. In this
example, it is 4 from head1.

Since it’s the first and only node in the merged list, it will also be the tail. Then move
head1 one step forward.

Conclusion

C is the foundational language from which practically all other languages are built. C
is the programming language's base. For writing system applications, it is a very
popular and frequently used language. Even if new languages have surpassed it in
popularity, it remains one of the most popular programming languages. The C
questions listed here will aid you in interviews as well as improve your learning. I
hope you found these to be helpful!

Additional Interview Resources

 C++ Interview Questions

 Practice Coding
 Difference Between C and C++
 Difference Between C and Java
 Features of C Language
 C Programming MCQs
 C IDE
 C Projects
 Technical Interview Questions
 Coding Interview Questions

C MCQ
1.

C variable cannot start with which of the following option

An alphabet

A number

A special symbol other than underscore

Both (b) and (c)

2.

During function call, Default Parameter Passing Mechanism is called as

 Call by Value

Call by Reference

Call by Address

Call by Name

3.

The statement printf(“%d”, 10 ? 0 ? 5 : 1 : 12); will print?

10

12

4.

In the switch statement, each case instance value must be _______?

Constant

Variable

Special Symbol

None of the above

5.

Which is the correct syntax to declare constants in C?

int constant var =10;

int const var = 10;

const int var = 10;

B & C Both

6.
Bitwise operators can operate upon?

double and chars

floats and doubles

ints and floats

ints and chars

7.

The number of binary trees that can be formed using 5 nodes are

30

42

108

36

8.

What is the correct syntax to access the value of struct variable book{ price, page }?

printf("%d%d", [Link], [Link]);

printf("%d%d", [Link], [Link]);

printf("%d%d", price::book, page::book);

printf("%d%d", price->book, page->book);

9.

Which of the following data structures is linear type?

Strings

Queue

Lists

All of the above

10.

A binary tree with 27 nodes has _______ null branches.

54

27

26

None of the above

1) What is C language?
C is a mid-level and procedural programming language. The Procedural
programming language is also known as the structured programming language is a
technique in which large programs are broken down into smaller modules, and each
module uses structured code. This technique minimizes error and
misinterpretation. More details.

2) Why is C known as a mother language?

C is known as a mother language because most of the compilers and JVMs are
written in C language. Most of the languages which are developed after C language
has borrowed heavily from it like C++, Python, Rust, javascript, etc. It introduces new
core concepts like arrays, functions, file handling which are used in these
languages. More details.

3) Why is C called a mid-level programming language?

C is called a mid-level programming language because it binds the low level and
high -level programming language. We can use C language as a System
programming to develop the operating system as well as an Application
programming to generate menu driven customer driven billing system. More details.

4) Who is the founder of C language?

Dennis Ritchie. More details.

5) When was C language developed?

C language was developed in 1972 at bell laboratories of AT&T. More details.

6) What are the features of the C language?

The main features of C language are given below:

o Simple: C is a simple language because it follows the structured approach, i.e.,

a program is broken into parts
o Portable: C is highly portable means that once the program is written can be
run on any machine with little or no modifications.
o Mid Level: C is a mid-level programming language as it combines the low-
level language with the features of the high-level language.
o Structured: C is a structured language as the C program is broken into parts.
o Fast Speed: C language is very fast as it uses a powerful set of data types and
operators.
o Memory Management: C provides an inbuilt memory function that saves the
memory and improves the efficiency of our program.
o Extensible: C is an extensible language as it can adopt new features in the
future.

More details.

7) What is the use of printf() and scanf() functions?

printf(): The printf() function is used to print the integer, character, float and string
values on to the screen.

Following are the format specifier:

 o %d: It is a format specifier used to print an integer value.
o %s: It is a format specifier used to print a string.
o %c: It is a format specifier used to display a character value.
o %f: It is a format specifier used to display a floating point value.

scanf(): The scanf() function is used to take input from the user.

More details.

8) What is the difference between the local variable and global

variable in C?
Following are the differences between a local variable and global variable:

Basis for Local variable Global variable

comparison

Declaration A variable which is declared A variable which is declared

inside function or block is outside function or block is
known as a local variable. known as a global variable.

Scope The scope of a variable is The scope of a variable is

available within a function in available throughout the
which they are declared. program.

Access Variables can be accessed only Any statement in the entire

by those statements inside a program can access variables.
function in which they are
declared.

Life Life of a variable is created Life of a variable exists until the

when the function block is program is executing.
entered and destroyed on its
exit.

Storage Variables are stored in a stack The compiler decides the storage
unless specified. location of a variable.
More details.
9) What is the use of a static variable in C?
Following are the uses of a static variable:

o A variable which is declared as static is known as a static variable. The static

variable retains its value between multiple function calls.
o Static variables are used because the scope of the static variable is available in
the entire program. So, we can access a static variable anywhere in the
program.
o The static variable is initially initialized to zero. If we update the value of a
variable, then the updated value is assigned.
o The static variable is used as a common value which is shared by all the
methods.
o The static variable is initialized only once in the memory heap to reduce the
memory usage.

More details.

10) What is the use of the function in C?

Uses of C function are:

o C functions are used to avoid the rewriting the same code again and again in
our program.
o C functions can be called any number of times from any place of our program.
o When a program is divided into functions, then any part of our program can
easily be tracked.
o C functions provide the reusability concept, i.e., it breaks the big task into
smaller tasks so that it makes the C program more understandable.

More details.

11) What is the difference between call by value and call by

reference in C?
Following are the differences between a call by value and call by reference are:
 Call by value Call by reference

Description When a copy of the value is passed to the When a copy of the value is
function, then the original value is not passed to the function, then the
modified. original value is modified.

Memory Actual arguments and formal arguments Actual arguments and formal
location are created in separate memory locations. arguments are created in the
same memory location.

Safety In this case, actual arguments remain safe In this case, actual arguments
as they cannot be modified. are not reliable, as they are
modified.

Arguments The copies of the actual arguments are The addresses of actual
passed to the formal arguments. arguments are passed to their
respective formal arguments.

Example of call by value:

1. #include <stdio.h>
2. void change(int,int);
3. int main()
4. {
5. int a=10,b=20;
6. change(a,b); //calling a function by passing the values of variables.
7. printf("Value of a is: %d",a);
8. printf("\n");
9. printf("Value of b is: %d",b);
10. return 0;
11. }
12. void change(int x,int y)
13. {
14. x=13;
15. y=17;
16. }
 Output:

Value of a is: 10
Value of b is: 20

Example of call by reference:

Learn more

1. #include <stdio.h>
2. void change(int*,int*);
3. int main()
4. {
5. int a=10,b=20;
6. change(&a,&b); // calling a function by passing references of variables.
7. printf("Value of a is: %d",a);
8. printf("\n");
9. printf("Value of b is: %d",b);
10. return 0;
11. }
12. void change(int *x,int *y)
13. {
14. *x=13;
15. *y=17;
16. }

Output:

Value of a is: 13
Value of b is: 17

More details.

12) What is recursion in C?

When a function calls itself, and this process is known as recursion. The function that
calls itself is known as a recursive function.
 Recursive function comes in two phases:

1. Winding phase
2. Unwinding phase

Winding phase: When the recursive function calls itself, and this phase ends when
the condition is reached.

Unwinding phase: Unwinding phase starts when the condition is reached, and the
control returns to the original call.

Example of recursion

1. #include <stdio.h>
2. int calculate_fact(int);
3. int main()
4. {
5. int n=5,f;
6. f=calculate_fact(n); // calling a function
7. printf("factorial of a number is %d",f);
8. return 0;
9. }
10. int calculate_fact(int a)
11. {
12. if(a==1)
13. {
14. return 1;
15. }
16. else
17. return a*calculate_fact(a-1); //calling a function recursively.
18. }

Output:

factorial of a number is 120

More details.
 13) What is an array in C?
An Array is a group of similar types of elements. It has a contiguous memory
location. It makes the code optimized, easy to traverse and easy to sort. The size and
type of arrays cannot be changed after its declaration.

Arrays are of two types:

o One-dimensional array: One-dimensional array is an array that stores the

elements one after the another.

Syntax:

Learn more

1. data_type array_name[size];

o Multidimensional array: Multidimensional array is an array that contains

more than one array.

Syntax:

1. data_type array_name[size];

Example of an array:

1. #include <stdio.h>
2. int main()
3. {
4. int arr[5]={1,2,3,4,5}; //an array consists of five integer values.
5. for(int i=0;i<5;i++)
6. {
7. printf("%d ",arr[i]);
8. }
9. return 0;
10. }

Output:

1 2 3 4 5
More details.

14) What is a pointer in C?

A pointer is a variable that refers to the address of a value. It makes the code
optimized and makes the performance fast. Whenever a variable is declared inside a
program, then the system allocates some memory to a variable. The memory
contains some address number. The variables that hold this address number is
known as the pointer variable.

For example:

1. Data_type *p;

The above syntax tells that p is a pointer variable that holds the address number of a
given data type value.

Example of pointer

1. #include <stdio.h>
2. int main()
3. {
4. int *p; //pointer of type integer.
5. int a=5;
6. p=&a;
7. printf("Address value of 'a' variable is %u",p);
8. return 0;
9. }

Output:

Address value of 'a' variable is 428781252

More details.

15) What is the usage of the pointer in C?

o Accessing array elements: Pointers are used in traversing through an array of

integers and strings. The string is an array of characters which is terminated by
a null character '\0'.
o Dynamic memory allocation: Pointers are used in allocation and deallocation
of memory during the execution of a program.
o Call by Reference: The pointers are used to pass a reference of a variable to
other function.
o Data Structures like a tree, graph, linked list, etc.: The pointers are used to
construct different data structures like tree, graph, linked list, etc.

16) What is a NULL pointer in C?

A pointer that doesn't refer to any address of value but NULL is known as a NULL
pointer. When we assign a '0' value to a pointer of any type, then it becomes a Null
pointer.

More details.

17) What is a far pointer in C?

 A pointer which can access all the 16 segments (whole residence memory) of RAM is
known as far pointer. A far pointer is a 32-bit pointer that obtains information
outside the memory in a given section.

18) What is dangling pointer in C?

o If a pointer is pointing any memory location, but meanwhile another pointer

deletes the memory occupied by the first pointer while the first pointer still
points to that memory location, the first pointer will be known as a dangling
pointer. This problem is known as a dangling pointer problem.
o Dangling pointer arises when an object is deleted without modifying the value
of the pointer. The pointer points to the deallocated memory.

Let's see this through an example.

1. #include<stdio.h>
2. void main()
3. {
4. int *ptr = malloc(constant value); //allocating a memory space.
5. free(ptr); //ptr becomes a dangling pointer.
6. }

In the above example, initially memory is allocated to the pointer variable ptr, and
then the memory is deallocated from the pointer variable. Now, pointer variable, i.e.,
ptr becomes a dangling pointer.

How to overcome the problem of a dangling pointer

The problem of a dangling pointer can be overcome by assigning a NULL value to

the dangling pointer. Let's understand this through an example:

1. #include<stdio.h>
2. void main()
3. {
4. int *ptr = malloc(constant value); //allocating a memory space.
5. free(ptr); //ptr becomes a dangling pointer.
6. ptr=NULL; //Now, ptr is no longer a dangling pointer.
7. }

In the above example, after deallocating the memory from a pointer variable, ptr is
assigned to a NULL value. This means that ptr does not point to any memory
location. Therefore, it is no longer a dangling pointer.

19) What is pointer to pointer in C?

In case of a pointer to pointer concept, one pointer refers to the address of another
pointer. The pointer to pointer is a chain of pointers. Generally, the pointer contains
the address of a variable. The pointer to pointer contains the address of a first
pointer. Let's understand this concept through an example:

1. #include <stdio.h>
2. int main()
3. {
4. int a=10;
5. int *ptr,**pptr; // *ptr is a pointer and **pptr is a double pointer.
6. ptr=&a;
7. pptr=&ptr;
8. printf("value of a is:%d",a);
9. printf("\n");
10. printf("value of *ptr is : %d",*ptr);
11. printf("\n");
12. printf("value of **pptr is : %d",**pptr);
13. return 0;
14. }

In the above example, pptr is a double pointer pointing to the address of the ptr
variable and ptr points to the address of 'a' variable.
 More details.

20) What is static memory allocation?

o In case of static memory allocation, memory is allocated at compile time, and

memory can't be increased while executing the program. It is used in the
array.
o The lifetime of a variable in static memory is the lifetime of a program.
o The static memory is allocated using static keyword.
o The static memory is implemented using stacks or heap.
o The pointer is required to access the variable present in the static memory.
o The static memory is faster than dynamic memory.
o In static memory, more memory space is required to store the variable.

1. For example:
2. int a[10];

The above example creates an array of integer type, and the size of an array is fixed,
i.e., 10.

More details.

21) What is dynamic memory allocation?

o In case of dynamic memory allocation, memory is allocated at runtime and

memory can be increased while executing the program. It is used in the linked
list.
o The malloc() or calloc() function is required to allocate the memory at the
runtime.
 o An allocation or deallocation of memory is done at the execution time of a
program.
o No dynamic pointers are required to access the memory.
o The dynamic memory is implemented using data segments.
o Less memory space is required to store the variable.

1. For example
2. int *p= malloc(sizeof(int)*10);

The above example allocates the memory at runtime.

More details.

22) What functions are used for dynamic memory allocation in

C language?

1. malloc()
o The malloc() function is used to allocate the memory during the
execution of the program.
o It does not initialize the memory but carries the garbage value.
o It returns a null pointer if it could not be able to allocate the requested
space.

Syntax

1. ptr = (cast-type*) malloc(byte-

size) // allocating the memory using malloc() function.

2. calloc()
 o The calloc() is same as malloc() function, but the difference only is that
it initializes the memory with zero value.

Syntax

1. ptr = (cast-type*)calloc(n, element-

size);// allocating the memory using calloc() function.

2. realloc()
o The realloc() function is used to reallocate the memory to the new size.
o If sufficient space is not available in the memory, then the new block is
allocated to accommodate the existing data.

Syntax

1. ptr = realloc(ptr, newsize); // updating the memory size using realloc() functio
n.

In the above syntax, ptr is allocated to a new size.

2. free():The free() function releases the memory allocated by either calloc() or

malloc() function.

Syntax

1. free(ptr); // memory is released using free() function.

The above syntax releases the memory from a pointer variable ptr.

More details.
 23) What is the difference between malloc() and calloc()?

calloc() malloc()

Description The malloc() function allocates a single The calloc() function allocates
block of requested memory. multiple blocks of requested
memory.

Initialization It initializes the content of the memory It does not initialize the content
to zero. of memory, so it carries the
garbage value.

Number of It consists of two arguments. It consists of only one

arguments argument.

Return value It returns a pointer pointing to the It returns a pointer pointing to

allocated memory. the allocated memory.

More details.

Learn more

24) What is the structure?

o The structure is a user-defined data type that allows storing multiple types of
data in a single unit. It occupies the sum of the memory of all members.
o The structure members can be accessed only through structure variables.
o Structure variables accessing the same structure but the memory allocated for
each variable will be different.

Syntax of structure

1. struct structure_name
2. {
3. Member_variable1;
4. Member_variable2
5. .
6. .
7. }[structure variables];

Let's see a simple example.

1. #include <stdio.h>
2. struct student
3. {
4. char name[10]; // structure members declaration.
5. int age;
6. }s1; //structure variable
7. int main()
8. {
9. printf("Enter the name");
10. scanf("%s",[Link]);
11. printf("\n");
12. printf("Enter the age");
13. scanf("%d",&[Link]);
14. printf("\n");
15. printf("Name and age of a student: %s,%d",[Link],[Link]);
16. return 0;
17. }

Output:

Enter the name shikha

Enter the age 26
Name and age of a student: shikha,26

More details.

25) What is a union?

 o The union is a user-defined data type that allows storing multiple types of
data in a single unit. However, it doesn't occupy the sum of the memory of all
members. It holds the memory of the largest member only.
o In union, we can access only one variable at a time as it allocates one common
space for all the members of a union.

Syntax of union

1. union union_name
2. {
3. Member_variable1;
4. Member_variable2;
5. .
6. .
7. Member_variable n;
8. }[union variables];

Let's see a simple example

1. #include<stdio.h>
2. union data
3. {
4. int a; //union members declaration.
5. float b;
6. char ch;
7. };
8. int main()
9. {
10. union data d; //union variable.
11. d.a=3;
12. d.b=5.6;
13. [Link]='a';
14. printf("value of a is %d",d.a);
15. printf("\n");
16. printf("value of b is %f",d.b);
17. printf("\n");
18. printf("value of ch is %c",[Link]);
19. return 0;
20. }

Output:

value of a is 1085485921
value of b is 5.600022
value of ch is a

In the above example, the value of a and b gets corrupted, and only variable ch
shows the actual output. This is because all the members of a union share the
common memory space. Hence, the variable ch whose value is currently updated.

More details.

26) What is an auto keyword in C?

In C, every local variable of a function is known as an automatic (auto) variable.
Variables which are declared inside the function block are known as a local variable.
The local variables are also known as an auto variable. It is optional to use an auto
keyword before the data type of a variable. If no value is stored in the local variable,
then it consists of a garbage value.

27) What is the purpose of sprintf() function?

The sprintf() stands for "string print." The sprintf() function does not print the output
on the console screen. It transfers the data to the buffer. It returns the total number
of characters present in the string.

Syntax
1. int sprintf ( char * str, const char * format, ... );

Let's see a simple example

1. #include<stdio.h>
2. int main()
3. {
4. char a[20];
5. int n=sprintf(a,"javaToint");
6. printf("value of n is %d",n);
7. return 0;}

Output:

value of n is 9

28) Can we compile a program without main() function?

Yes, we can compile, but it can't be executed.

But, if we use #define, we can compile and run a C program without using the main()
function. For example:

1. #include<stdio.h>
2. #define start main
3. void start() {
4. printf("Hello");
5. }

More details.
 29) What is a token?
The Token is an identifier. It can be constant, keyword, string literal, etc. A token is
the smallest individual unit in a program. C has the following tokens:

1. Identifiers: Identifiers refer to the name of the variables.

2. Keywords: Keywords are the predefined words that are explained by the
compiler.
3. Constants: Constants are the fixed values that cannot be changed during the
execution of a program.
4. Operators: An operator is a symbol that performs the particular operation.
5. Special characters: All the characters except alphabets and digits are treated
as special characters.

30) What is command line argument?

The argument passed to the main() function while executing the program is known
as command line argument. For example:

1. main(int count, char *args[]){

2. //code to be executed
3. }

31) What is the acronym for ANSI?

The ANSI stands for " American National Standard Institute." It is an organization that
maintains the broad range of disciplines including photographic film, computer
languages, data encoding, mechanical parts, safety and more.

32) What is the difference between getch() and getche()?

The getch() function reads a single character from the keyboard. It doesn't use any
buffer, so entered data will not be displayed on the output screen.
 The getche() function reads a single character from the keyword, but data is
displayed on the output screen. Press Alt+f5 to see the entered character.

Let's see a simple example

1. #include<stdio.h>
2. #include<conio.h>
3. int main()
4. {
5.
6. char ch;
7. printf("Enter a character ");
8. ch=getch(); // taking an user input without printing the value.
9. printf("\nvalue of ch is %c",ch);
10. printf("\nEnter a character again ");
11. ch=getche(); // taking an user input and then displaying it on the screen.
12. printf("\nvalue of ch is %c",ch);
13. return 0;
14. }

Output:

Enter a character
value of ch is a
Enter a character again a
value of ch is a

In the above example, the value entered through a getch() function is not displayed
on the screen while the value entered through a getche() function is displayed on the
screen.

33) What is the newline escape sequence?

The new line escape sequence is represented by "\n". It inserts a new line on the
output screen.

More details.
 34) Who is the main contributor in designing the C language
after Dennis Ritchie?
Brain Kernighan.

35) What is the difference between near, far and huge

pointers?
A virtual address is composed of the selector and offset.

A near pointer doesn't have explicit selector whereas far, and huge pointers have
explicit selector. When you perform pointer arithmetic on the far pointer, the selector
is not modified, but in case of a huge pointer, it can be modified.

These are the non-standard keywords and implementation specific. These are
irrelevant in a modern platform.

36) What is the maximum length of an identifier?

It is 32 characters ideally but implementation specific.

37) What is typecasting?

The typecasting is a process of converting one data type into another is known as
typecasting. If we want to store the floating type value to an int type, then we will
convert the data type into another data type explicitly.

Syntax

1. (type_name) expression;
38) What are the functions to open and close the file in C
language?
The fopen() function is used to open file whereas fclose() is used to close file.

39) Can we access the array using a pointer in C language?

Yes, by holding the base address of array into a pointer, we can access the array
using a pointer.

1. Which of the following statements should be used to obtain a remainder after dividing 3.14 by
2.1 ?
A. rem = 3.14 % 2.1;

B. rem = modf(3.14, 2.1);

C. rem = fmod(3.14, 2.1);

D. Remainder cannot be obtain in floating point division.

Answer: Option C
Explanation:
fmod(x,y) - Calculates x modulo y, the remainder of x/y.
This function is the same as the modulus operator. But fmod() performs floating point
divisions.
Example:

#include <stdio.h>
#include <math.h>

int main ()
{
printf ("fmod of 3.14/2.1 is %lf\n", fmod (3.14,2.1) );
return 0;
}

Output:
fmod of 3.14/2.1 is 1.040000
View Answer Discuss in Forum Workspace Report

2. What are the types of linkages?

A. Internal and External

B. External, Internal and None

C. External and None

D. Internal
Answer: Option B
Explanation:
 External Linkage-> means global, non-static variables and functions.
Internal Linkage-> means static variables and functions with file scope.
None Linkage-> means Local variables.
View Answer Discuss in Forum Workspace Report

3. Which of the following special symbol allowed in a variable name?

A. * (asterisk)

B. | (pipeline)

C. - (hyphen)

D. _ (underscore)
Answer: Option D
Explanation:
Variable names in C are made up of letters (upper and lower case) and digits. The
underscore character ("_") is also permitted. Names must not begin with a digit.
Examples of valid (but not very descriptive) C variable names:
=> foo
=> Bar
=> BAZ
=> foo_bar
=> _foo42
=> _
=> QuUx
View Answer Discuss in Forum Workspace Report

4. Is there any difference between following declarations?

1 : extern int fun();
2 : int fun();

A. Both are identical

B. No difference, except extern int fun(); is probably in another file

C. int fun(); is overrided with extern int fun();

D. None of these
Answer: Option B
Explanation:
extern int fun(); declaration in C is to indicate the existence of a global function and it
is defined externally to the current module or in another file.
int fun(); declaration in C is to indicate the existence of a function inside the current
module or in the same file.
View Answer Discuss in Forum Workspace Report

5. How would you round off a value from 1.66 to 2.0?

A. ceil(1.66)

B. floor(1.66)
 C. roundup(1.66)

D. roundto(1.66)
Answer: Option A
Explanation:
/* Example for ceil() and floor() functions: */

#include<stdio.h>
#include<math.h>

int main()
{
printf("\n Result : %f" , ceil(1.44) );
printf("\n Result : %f" , ceil(1.66) );

printf("\n Result : %f" , floor(1.44) );

printf("\n Result : %f" , floor(1.66) );

return 0;
}
// Output:
// Result : 2.000000
// Result : 2.000000
// Result : 1.000000
// Result : 1.000000

View Answer Discuss in Forum Workspace Report

6. By default a real number is treated as a
A. float

B. double

C. long double

D. far double
Answer: Option B
Explanation:
In computing, 'real number' often refers to non-complex floating-point numbers. It include
both rational numbers, such as 42 and 3/4, and irrational numbers such as pi =
3.14159265...
When the accuracy of the floating point number is insufficient, we can use the double to
define the number. The double is same as float but with longer precision and takes
double space (8 bytes) than float.
To extend the precision further we can use long double which occupies 10 bytes of
memory space.
View Answer Discuss in Forum Workspace Report

7. Which of the following is not user defined data type?

1:
struct book
{
char name[10];
float price;
int pages;
 };

2:
long int l = 2.35;

3:
enum day {Sun, Mon, Tue, Wed};

A. 1

B. 2

C. 3

D. Both 1 and 2
Answer: Option B
Explanation:
C data types classification are
1. Primary data types
1. int
2. char
3. float
4. double
5. void
2. Secondary data types (or) User-defined data type
1. Array
2. Pointer
3. Structure
4. Union
5. Enum
So, clearly long int l = 2.35; is not User-defined data type.
([Link] int l = 2.35; is the answer.)
View Answer Discuss in Forum Workspace Report

8. Is the following statement a declaration or definition?

extern int i;
A. Declaration

B. Definition

C. Function

D. Error
Answer: Option A
Explanation:
Declaring is the way a programmer tells the compiler to expect a particular type, be it a
variable, class/struct/union type, a function type (prototype) or a particular object instance.
 (ie. extern int i)
Declaration never reserves any space for the variable or instance in the program's memory;
it simply a "hint" to the compiler that a use of the variable or instance is expected in the
program. This hinting is technically called "forward reference".
View Answer Discuss in Forum Workspace Report

9. Identify which of the following are declarations

1 : extern int x;
2 : float square ( float x ) { ... }
3 : double pow(double, double);
A. 1

B. 2

C. 1 and 3

D. 3
Answer: Option C
Explanation:
extern int x; - is an external variable declaration.

double pow(double, double); - is a function prototype declaration.

Therefore, 1 and 3 are declarations. 2 is definition.

View Answer Discuss in Forum Workspace Report

10. In the following program where is the variable a getting defined and where it is getting
declared?
#include<stdio.h>
int main()
{
extern int a;
printf("%d\n", a);
return 0;
}
int a=20;

A. extern int a is declaration, int a = 20 is the definition

B. int a = 20 is declaration, extern int a is the definition

C. int a = 20 is definition, a is not defined

D. a is declared, a is not defined

Answer: Option A
Explanation:
- During declaration we tell the datatype of the Variable.
- During definition the value is initialized.
When we mention the prototype of a function?
 A. Defining

B. Declaring

C. Prototyping

D. Calling
Answer: Option B
Explanation:
A function prototype in C or C++ is a declaration of a function that omits the function body but
does specify the function's name, argument types and return type.
While a function definition specifies what a function does, a function prototype can be
thought of as specifying its interface.
1. What is the output of the program given below ?
#include<stdio.h>
int main()
{
enum status { pass, fail, atkt};
enum status stud1, stud2, stud3;
stud1 = pass;
stud2 = atkt;
stud3 = fail;
printf("%d, %d, %d\n", stud1, stud2, stud3);
return 0;
}

A. 0, 1, 2

B. 1, 2, 3

C. 0, 2, 1

D. 1, 3, 2
Answer: Option C
Explanation:
enum takes the format like {0,1,2..) so pass=0, fail=1, atkt=2
stud1 = pass (value is 0)
stud2 = atkt (value is 2)
stud3 = fail (value is 1)
Hence it prints 0, 2, 1
View Answer Discuss in Forum Workspace Report

2. What will be the output of the program in 16 bit platform (Turbo C under DOS)?
#include<stdio.h>
int main()
{
extern int i;
i = 20;
printf("%d\n", sizeof(i));
return 0;
}

A. 2
 B. 4

C. vary from compiler

D. Linker Error : Undefined symbol 'i'

Answer: Option D
Explanation:
Linker Error : Undefined symbol 'i'
The statement extern int i specifies to the compiler that the memory for 'i' is allocated
in some other program and that address will be given to the current program at the time of
linking. But linker finds that no other variable of name 'i' is available in any other program
with memory space allocated for it. Hence a linker error has occurred.
View Answer Discuss in Forum Workspace Report

3. What is the output of the program?

#include<stdio.h>
int main()
{
extern int a;
printf("%d\n", a);
return 0;
}
int a=20;

A. 20

B. 0

C. Garbage Value

D. Error
Answer: Option A
Explanation:
extern int a; indicates that the variable a is defined elsewhere, usually in a separate
source code module.
printf("%d\n", a); it prints the value of local variable int a = 20. Because, whenever
there is a conflict between local variable and global variable, local variable gets the highest
priority. So it prints 20.
View Answer Discuss in Forum Workspace Report

4. What is the output of the program in Turbo C (in DOS 16-bit OS)?
#include<stdio.h>
int main()
{
char *s1;
char far *s2;
char huge *s3;
printf("%d, %d, %d\n", sizeof(s1), sizeof(s2), sizeof(s3));
return 0;
}

A. 2, 4, 6
 B. 4, 4, 2

C. 2, 4, 4

D. 2, 2, 2
Answer: Option C
Explanation:
Any pointer size is 2 bytes. (only 16-bit offset)
So, char *s1 = 2 bytes.
So, char far *s2; = 4 bytes.
So, char huge *s3; = 4 bytes.
A far, huge pointer has two parts: a 16-bit segment value and a 16-bit offset value.
Since C is a compiler dependent language, it may give different output in other platforms.
The above program works fine in Windows (TurboC), but error in Linux (GCC Compiler).
View Answer Discuss in Forum Workspace Report

5. What is the output of the program

#include<stdio.h>
int main()
{
struct emp
{
char name[20];
int age;
float sal;
};
struct emp e = {"Tiger"};
printf("%d, %f\n", [Link], [Link]);
return 0;
}

A. 0, 0.000000

B. Garbage values

C. Error

D. None of above
Answer: Option A
Explanation:
When an automatic structure is partially initialized remaining elements are initialized to
0(zero).
View Answer Discuss in Forum Workspace Report

What will be the output of the program?

#include<stdio.h>
int X=40;
int main()
{
int X=20;
printf("%d\n", X);
return 0;
}
 A. 20

B. 40

C. Error

D. No Output
Answer: Option A
Explanation:
Whenever there is conflict between a local variable and global variable, the local variable gets
priority.
View Answer Discuss in Forum Workspace Report

7. What is the output of the program

#include<stdio.h>
int main()
{
int x = 10, y = 20, z = 5, i;
i = x < y < z;
printf("%d\n", i);
return 0;
}

A. 0

B. 1

C. Error

D. None of these
Answer: Option B
Explanation:
Since x < y turns to be TRUE it is replaced by 1. Then 1 < z is compared and to be TRUE.
The 1 is assigned to i.
View Answer Discuss in Forum Workspace Report

8. What is the output of the program

#include<stdio.h>
int main()
{
extern int fun(float);
int a;
a = fun(3.14);
printf("%d\n", a);
return 0;
}
int fun(int aa)
{
return (int)++aa;
}

A. 3

B. 3.14
 C. 0

D. 4

E. Compile Error
Answer: Option E
Explanation:
2 Errors
1. Type mismatch in redeclaration of fun
2. Type mismatch in parameter aa
View Answer Discuss in Forum Workspace Report

9. What is the output of the program

#include<stdio.h>
int main()
{
int a[5] = {2, 3};
printf("%d, %d, %d\n", a[2], a[3], a[4]);
return 0;
}

A. Garbage Values

B. 2, 3, 3

C. 3, 2, 2

D. 0, 0, 0
Answer: Option D
Explanation:
When an automatic array is partially initialized, the remaining elements are initialized to 0.
View Answer Discuss in Forum Workspace Report

10. What is the output of the program?

#include<stdio.h>
int main()
{
union a
{
int i;
char ch[2];
};
union a u;
[Link][0] = 3;
[Link][1] = 2;
printf("%d, %d, %d\n", [Link][0], [Link][1], u.i);
return 0;
}

A. 3, 2, 515

B. 515, 2, 3

C. 3, 2, 5
 D. None of these
Answer: Option A
Explanation:
printf("%d, %d, %d\n", [Link][0], [Link][1], u.i); It prints the value of [Link][0] =
3, [Link][1] = 2 and it prints the value of u.i means the value of entire union size.

So the output is 3, 2, 515.

11. In the following program how long will the for loop get executed?
#include<stdio.h>
int main()
{
int i=5;
for(;scanf("%s", &i); printf("%d\n", i));
return 0;
}

A. The for loop would not get executed at all

B. The for loop would get executed only once

C. The for loop would get executed 5 times

D. The for loop would get executed infinite times

Answer: Option D
Explanation:
During the for loop execution scanf() ask input and then printf() prints that given input.
This process will be continued repeatedly because, scanf() returns the number of input
given, the condition is always true(user gives a input means it reurns '1').
Hence this for loop would get executed infinite times.
View Answer Discuss in Forum Workspace Report

12. What will be the output of the program?

#include<stdio.h>
int main()
{
int X=40;
{
 int X=20;
printf("%d ", X);
}
printf("%d\n", X);
return 0;
}

A. 40 40

B. 20 40

C. 20

D. Error
Answer: Option B
Explanation:
In case of a conflict between a local variable and global variable, the local variable gets
priority.