0Q1. What are the two forms of #include?
There are two variants of #include. The one is #include and the other one is #include”file”. In general the first form that is #include 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 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 registerkey 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.
