Some Interview Questions for freshers on C language - Part 1

In this post I am giving my thoughts on some fundamental questions on C language which are expected to be asked in a standard interview session for freshers.

Q1. What are the two forms of #include?

There are two variants of #include. The one is #include<file> and the other one is #include”file”. In general the first form that is #include<file> is used to include system defined header files which are searched in the standard list of system directories. The second form i,e #include”file” is generally used to include user defined header files. These files are searched first in the current directory , if failed, then secondly in the standard list of system directories.

Both the forms of #include share a common property that is no escape sequence or commenting  styles are recognized within <file> or “file”. What I mean to say is that if I write #include <x/*y>, that means I want to include a file named x/*y.  Similarly writing #include<x\y\\z> is also perfect if the file x\y\\z is needed to be included.

   

Q2. What is the difference between Function and Subroutine?

The difference is indeed very thin and it depends on the context. In general Function is a piece of code with a name, inputs (arguments) and an output (return types). That is function should always return. Some programming languages are there which uniquely maps inputs to the corresponding outputs. But surely C is not such.  There is also a convention (but not a very strict one) that a function should not change any global variable. In C language, a function is always a realistic part of the code.

Subroutine is just a piece of any sorts of code with a definite entry and exit point. It should not return anything and a subroutine can always change global variables. These are generally used for conceptual purposes like in psudocodes.

Q3. What are register variables?

Registers are faster than memories to access. Hence when we declare a variable with a register key word, the compiler gets to know that the variable can be put to registers. Now whether the variables will be put into the register indeed or not, that depends on the compiler and the number and size of the registers for the corresponding hardware.

In general, the variables which are to be used with high frequencies (like loop variables) are the perfect choice for declaring as register, because the gain in speed would be considerable in those cases.

It is not allowed to access the address of the register variables as accessing the address of the register is illegal.

It is perfectly all right to declare a pointer as register because a register can always store the address of other variables if the size of the register permits that to do.

Q4. What is the difference between Scope and Lifetime?

Scope of a variable is defined as the block of code from where we can refer or access it. On the other hand the life time of a variable is defined as the time in between allocating memory for it and relinquishing the memory from it.  Let us have an example

void func1(void){

int x = 5;

// do other stuffs

}

void func2(void){

int y = 10;

func1();

//do other stuffs

}

In the above example scope of x is func1 and scope of y is func2. Now when we call func1 from func2, then inside func1, scope of y is ended but the life time of y still persists,  because the memory for y is still not relinquished.

Q5. What is your thoughts on the memory model of C with respect to the storage classes?

The entire memory (with respect to C program) can be divided into four logical segments. Data, Stack, Code and Heap.  The Code area contains all the instructions of the current program code. Data contains the Static and Extern variables. Auto variables are stored in Stack. The Heap area will be occupied by dynamically allocated variables. Lastly the Register variables will find its place CPU registers.  

  

 In the next post I will be expressing my thoughts on different questions which may be asked to judge the level  of efficiency of a fresher on the topic of Pointers