Sunteți pe pagina 1din 50

Advanced C Interview Questions and Answers for

Experienced
Top 60 complex and advanced C Interview Questions and Answers for
Experienced programmers covering all aspects of C programming with detailed
explanations.

1) What will be the output of printf(“%d”)?


The ideal form of printf is printf("%d",x); where x is an integer variable.
Executing this statement will print the value of x. But here, there is no variable
is provided after %d so compiler will show garbage value. The reason is a bit
tricky.
When access specifiers are used in printf function, the compiler internally uses
those specifiers to access the arguments in the argument stack. In ideal scenario
compiler determines the variable offset based on the format specifiers provided.
If we write printf("%d", x) then compiler first accesses the first specifier which
is %d and depending on the that the offset of variable x in the memory is
calculated. But the printf function takes variable arguments.

The first argument which contains strings to be printed or format specifiers is


mandatory. Other than that, the arguments are optional.So, in case of only %d
used without any variable in printf, the compiler may generate warning but will
not cause any error. In this case, the correct offset based on %d is calculated by
compiler but as the actual data variable is not present in that calculated location
of memory, the printf will fetch integer size value and print whatever is there
(which is garbage value to us).

2) What is the return values of printf and scanf?


The printf function upon successful return, returns the number of characters
printed in output device. So, printf(“A”) will return 1. The scanf function
returns the number of input items successfully matched and assigned, which can
be fewer than the format specifiers provided. It can also return zero in case of
early matching failure.

3) How to free a block of memory previously allocated without using free?


If the pointer holding that memory address is passed to realloc with size
argument as zero (like realloc(ptr, 0)) the the memory will be released.

4) How can you print a string containing '%' in printf?


There are no escape sequence provided for '%' in C. To print '%' one should use
'%%', like -
printf(“He got 90%% marks in math”);

5) What is use of %n in printf()?


Ans: According to man page “the number of characters written so far is stored
into the integer. indicated by the int * (or variant) pointer argument.“. Meaning
if we use it in printf, it will get the number of characters already written until
%n is encountered and this number will stored in the variable provided. The
variable must be an integer pointer.

#include<stdio.h>
main()
{
int c;
printf("Hello%n world ",&c);
printf("%d", c);
}

Above program will print 'Hello world 5 “ as Hello is 5 letter.

6) Swap two variables without using any control statement ?


We can swap variable using 2 methods. First method is as given below
#include <stdio.h>
main()
{
int a = 6;
int b = 10;
a = a + b;
b = a - b;
a = a - b;
printf("a: %d, b: %d\n", a, b);
}

Second method to swap variables is given below

#include <stdio.h>
main()
{
int a = 6;
int b = 10;
a ^= b;
b ^= a;
a ^= b;
printf("a: %d, b: %d\n", a, b);
}

7) Consider the two structures Struct A and Struct B given below. What
will be size of these structures?
struct A
{
unsigned char c1 : 3;
unsigned char c2 : 4;
unsigned char c3 : 1;
}a;
struct A
{
unsigned char c1 : 3;
unsigned char : 0;
unsigned char c2 : 4;
unsigned char c3 : 1;
}a;

The size of the structures will be 1 and 2. In case of first structure, the members
will be assigned a byte as follows -

7 6 5 4 3 2 1 0

c3 c2 c2 c2 c2 c1 c1 c1

But in case of second structure -

8 7 6 5 4 3 2 1 0

c3 c2 c2 c2 c2 c1 c1 c1

The :0 field (0 width bit field) forces the next bit width member assignment to
start from the next nibble. By doing so, the c3 variable will be assigned a bit in
the next byte, resulting the size of the structure to 2.
8) How to call a function before main()?
To call a function pragma startup directive should be used. Pragma startup can
be used like this -

#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

But this pragma directive is compiler dependent. Gcc does not support this. So,
it will ignore the startup directive and will produce no error. But the output in
that case will be -
In main

9) What is rvalue and lvalue?


You can think lvalue as a left side operant in an assignment and rvalue is the
right. Also, you can remember lavlue as location. So, the lvalue means a
location where you can store any value. Say, for statement i = 20, the value 20
is to be stored in the location or address of the variable i. 20 here is rvalue. Then
the 20 = I, statement is not valid. It will result in compilation error “lvalue
required” as 20 does not represent any location.

10)How to pack a structure?


We can pack any structure using __attribute__((__packed__)) in gcc. Example -

typdef struct A __attribute __((__packed__))


{
char c;
int i;
}B;

We can also use, pragma pack like this -

#pragma pack(1)
typedef struct A
{
char c;
int I;
}B;

In both cases the size of the structure will be 5. But remember, the pragma pack
and the other method mentioned, both are compiler dependent.

11) How to convert a string to integer value?


We can convert a string to integer in two ways. Method 1:
int i = atoi(str);

Method 2:
sscanf(str, “%d”, &i);

12) Print the output of the following switch case program?


#include <stdio.h>
main()
{
int i = 3;

switch(i)
{
default:
printf("%d", i);

case 1:
printf("1\n");
case 2:
printf("2\n");

case 3:
printf("3\n");
}
}

Output of this program will be 3. The position of the default is before case 1.
So, even if there is no break after case 3, the execution will just exit switch case
and it will not go to default case.

13) How to prevent same header file getting included multiple times?
We can use ifndef and define preprocessors. Say the header file is hdrfile.h, then
we can write the header file like -
#ifndef _HDRFILE_H_
#define _HDRFILE_H_
#endif

The ifndef will check whether macro HDRFILE_H_ is defined or not. If it is not
defined, it will define the macro. From next time onward the statements inside
ifndef will not be included.

14) Which is better #define or enum?

 Enum values can be automatically generated by compiler if we let it. But all the
define values are to be mentioned specifically.
 Macro is preprocessor, so unlike enum which is a compile time entity, source
code has no idea about these macros. So, the enum is better if we use a
debugger to debug the code.
 If we use enum values in a switch and the default case is missing, some
compiler will give a warning.
 Enum always makes identifiers of type int. But the macro let us choose between
different integral types.
 Macro does not specifically maintain scope restriction unlike enum. For
example -

#include <stdio.h>
main()
{
{
#define A 10
printf("first A: %d\n", A);
}
{
printf("second A: %d\n", A);
}
}

Above program will print -

first A: 10
second A: 10

15) Print the output of this pointer program?


#include<stdio.h>
main()
{
char *p = "Pointers";
p[2] = 'z';
printf("%c", *p);
}

The program will crash. The pointer p points to string “Pointers”. But the string
in constant and C will not allow to change its values. Forcibly doing so, like we
did it, will cause crash of the program.

Last Updated: Tuesday, 10 January 2017 Hits: 34376

16) What is the difference between const char* p and char const* p?
In const char* p, the character pointed by pointer variable p is constant. This
value can not be changed but we can initialize p with other memory location. It
means the character pointed by p is constant but not p. In char const* p, the
pointer p is constant not the character referenced by it. So we can't assign p with
other location but we can change the value of the character pointed by p.

17) What is the point of using malloc(0)?


According to C standard, “ If the size of the space requested is zero, the
behavior is implementation defined: either a null pointer is returned, or the
behavior is as if the size were some nonzero value, except that the returned
pointer shall not be used to access an object”. But there is a benefit of this. The
pointer return after malloc(0) will be valid pointer and can be deallocated using
free() and it will not crash the program.

18) What is function pointer?


Function pointer, as the name suggests, points to a function. We can declare a
function pointer and point to a function. After that using that function pointer
we can call that function. Let's say, we have a function Hello which has
definition like this -
void Hello(int)

The pointer to that function will look like -

void (*ptr)(int);
Here, ptr is a function pointer that can point to function with no return type and
one integer argument. After declaration, we can point to function Hello like this
-
void (*ptr)(int) = NULL;
ptr = Hello;

After that we can call that function like this -


(*ptr)(30);

19) Declare a function pointer that points to a function which returns a


function pointer ?
To understand this concept, let us look at the following example.

#include<stdio.h>
void Hello();
typedef void (*FP)();
FP fun(int);

main()
{
FP (*ptr)(int) = NULL;
FP p;
ptr = fun;
p = (*fun)(30);
(*p)();
}

void Hello()
{
printf("Hello\n");
}

FP fun(int a)
{
FP p = Hello;
printf("Number is : %d\n", a);
return p;
}

In this program, we have a function Hello with no return type and no argument.
The function fun takes an integer argument and returns a function pointer that
can point to Hello(). First we have typdef the function pointer which can point
to a function with no return type and argument with identifier FP. That way it
will be easier to define the required function pointer. If we avoid typedef the
required function pointer (ptr) will look like this -
void (*(*ptr)())(int)

20) What is indirection?


In C when we use variable name to access the value it is direct access. If we use
pointer to get the variable value, it is indirection.

21) Write a C program to check your system endianness?


#include<stdio.h>
main ()
{
union Test
{
unsigned int i;
unsigned char c[2];
};

union Test a = {300};


if((a.c [0] == 1) &&
(a.c [1] == 44))
{
printf ("BIG ENDIAN\n");
}
else
{
printf ("LITTLE ENDIAN\n");
}
}

22) 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”, a.by.first, a.by.second);
}

23) How can you determine the size of an allocated portion of memory?
Ans: We can’t. During malloc or calloc system maintains a list for the pointer
allocated and sizeof memory which is used during free(). This is not accessible
to user.

24) Guess the output or error:


#include<stdio.h>
#define SQUARE(x) (x)*(x)
main()
{
int i = 5;
printf('%d\n”, SQUARE(++i));
}

Answer will be 49. The macro will be expanded like (++i) * (++i). But the ++
operator has higher precedence. So, the output will be 49.

25) How do you override a defined macro?


We can use #ifdef and #undef preprocessors. It can be done like this -
#ifdef A
#undef A
#endif
#define A 10

Here if macro A is defined it will be undefined using undef and again defined
using define.

26) Can math operations be performed on a void pointer?


No. Pointer addition and subtraction means advancing the pointer by a number
of elements. But in case of a void pointer, we don't know fpr sure what it's
pointing to, so we don't know the size of what it's pointing to. That is why
pointer arithmetic can not be used on void pointers.

27) What does the macro #line do?


The macro #line has the capability to change the current line number and
optionally the file name returned by the predefined macros __LINE__ and
__FILE__. Here also the line number will be incremented automatically after
the value is changed using #line. For example, consider the following program.
#include<stdio.h>
main()
{
printf("First: %d\n", __LINE__);
#line 0
printf("Second: %d\n", __LINE__);
printf("Third: %d\n", __LINE__);
}
The output will be -

First: 5
Second: 0
Third: 1

28) Guess the output or error of the C program given below?


#include<stdio.h>
#define DO_SOMETHING(x)
int i;
for(i = 0; i < 10; i++)
x += i;

main()
{
int i = 0;
DO_SOMETHING(i);
printf("\n%d", i + printf("1"));
}

This program will generate an compilation error, as the integer variable i is


declared twice. The macro DO_SOMETHING will be replaced before the
compilation and the result code will have “int i” declaration twice in the
program which will cause compilation error.

29) Print the output of this array pointer program ?


#include <stdio.h>
#include <stdio.h>
int main(void)
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int*)(&a + 1);
printf("%d %d\n", *(a + 1), *(ptr - 1));
return 0;
}
Output of this program - 2 5

Here a has type array[5] of int, and &a has type pointer to array[5] of int. So, ptr
will yield a pointer to the array[5] of int that comes after a. Subtracting 1 from
ptr will point to the last element of a which is 5. Remember, here &a and &a[0]
both will point to starting address of the array or the address of the first element.
But (&a + 1) points block of memory of size 5 times the sizeof int that comes
after the memory block of a, while (&a[0] + 1) return the address of the second
element.
30) Print the output of this C program on operator precedence?
#include <stdio.h>
int main(void)
{
int a, b, c, d;
a = 3;
b = 5;
c = a, b;
d = (a, b);
printf("c=%d ", c);
printf("d=%d\n", d);
return 0;
}

Output - 3 5

The comma in C is both a separator as well as an operator. Also, comma


operator has the least precedence. In the assignment operation of c, the comma
has less priority that assignment operator. So, c = a, b actually evaluates to (c =
a), b. But in case of assignment of variable d, the comma operator evaluates
both of its operands and returns the value of the second. So, d = (a, b) is
equivalent to d = b.

31) Print the output of value assignment to a C constant program?


#include<stdio.h>
void main()
{
int const * p=5;
printf("%d",++(*p));
}

This program will give a compiler error: Cannot modify a constant value. Here
p is a pointer to a "constant integer". But in the printf function, we tried to
change the value of the "constant integer" which is not allowed in C and thus
the compilation error.
32) Print the output of this data comparison C program?
#include<stdio.h>
main()
{
float me = 1.1;
double you = 1.1;
if(me==you)
printf("I love U");
else
printf("I hate U");
}
Output is "I hate U"

For floating point numbers (float, double, long double) the values cannot be
predicted exactly. Depending on the number of bytes, the precession with of the
value represented varies. Float takes 4 bytes and long double takes 10 bytes. So
float stores 0.9 with less precision than long double. So comparing them will
result false and thus the “I hate U' string is printed. It is better to avoid
comparing different type of floating point numbers.

33) Guess the output of the backspace and carriage return C program?
#include<stdio.h>
main()
{
printf("\nab");
printf("\bsi");
printf("\rha");
}

Output is "hai"

The “\b” in C represents backspace and \r carriage return. The “\b” will erase
the last character printed in the output. So, the first printf feed a newline
character and then prints ab. The second printf first erases b from ab and then
prints si. Until now the output is asi. The third printf encounters the “\r” and
move the cursor back to the beginning of the line and then prints ha overwriting
the as of the asi. So, the final output will be hai.
34) Print the output of this recursive function C Program?
void add(int a, int b)
{
int c;
c = a + b;
add (1,1);
}

The function will lead to stack overflow. Here, there is no terminating condition
and that is why it leads to infinite recursion which results in STACK
OVERFLOW. When a function is called,

 It will evaluate actual parameter expressions.


 It will allocate memory for local variables.
 It will store caller’s current address of execution.
 Then it executes rest of the function body and reaches end and returns to the
caller’s address.

Here without proper termination condition, the recursion will continue and the
memory is allocated for all the recursion instances. After certain time the
memory allocated for the programs stack will be full and it will cause stack
overflow.

35) Print the output of this format specifier C Program?


#include<stdio.h>
main()
{
char s[] = "Hello world";
int i = 7;
printf("%10.*s", i, s);
}

Output of this program is "Hello w"

In this program the format specifier is a bit different from normal %s. After the
“%” operator the 10 forces to print minimum 10 characters to be printed in
output. The “.*” followed by that takes an integer argument and represents the
number of characters to be printed from the string followed. So, the argument i
with value 7 forces to print first 7 characters of the variable s. The remaining 3
characters are filled by preceding blank spaces.

36) Guess the condition in place of X which lead to print “Hello world” as
output?
if(X)
{
printf(“Hello”);
}
else
{
printf(“ world”);
}

The program should look like this -


if(!printf(“Hello”)
{
printf(“Hello”);
}
else
{
printf(“ world”);
}

The printf(“Hello”) in if condition is executed and will print “Hello” in the


output and this printf will return number of characters printed i.e. 5. The
preceding “!” will turn it 0 which will cause the if condition to fail and execute
the printf statement in else block.

37) What will be the output of the following piece of code?


printf(“%d”, (int)sizeof('A'));

The output will be same as sizeof(int). In case 64 bit machine it will be 4. The
sizeof operator will change the 'A' to its ASCII value and to the sizeof operator
that ASCII value is nothing but an integer.

38) Print the output or error?


#include<stdio.h>
main()
{
int i=5;
printf("%d%d%d%d%d%d", i++, i--, ++i, --i, i);
}

Output of this program is 45545. The arguments in any function call are pushed
into the stack from left to right order. During evaluation those arguments are
popped out from the stack. So, ultimately. the evaluation is from right to left.
So, the last argument will result 5, the next one will result 4 and also the
variable i at that point will hold 4. The next one is again 5 and after that it is
again 5 as it is post decrement. The first one will return 4 and turn the value of i
to 5.

39) Print the output of this C program with math functions?


#define square(x) x*x
main()
{
int i;
i = 64/square(4);
printf("%d",i);
}

Program will produce the output - 64. The macro call square(4) will substituted
by 4*4 and the expression becomes i = 64/4*4 . Since / and * has equal priority
the expression will be evaluated based on the associativity which is left to right.
So, 64/4*4 will be equal to (64/4)*4 i.e. 16*4 = 64.

40) Guess the output or error?


#include<stdio.h>
struct A
{
int i;
char str[10];
float f;
};

main()
{
struct A a = {4};
printf("%d %s %f\n", a.i, a.str, a.f);
}

The program will print 4 0.0000. In C, when a structure variable in partially


initialized, other members of that variables will be initialized to 0 or NULL.
Here, a.str will be initialized to NULL and a.f will be initialized to 0.0000.

41) Print the output of this static storage class C program ?


#include<stdio.h>
main()
{
static int a[5];
int i = 0;
a[i] = i++;
printf("%d %d\n", a[0], a[1]);
}

Output - 0 0. The static storage class will initialize all the elements of the array
to 0. The 2nd element i.e. element with index 1 will be populated with 0 as the
increment is post increment. So, the output will be 0 0.

42) Guess the output of this sizeof C program?


main()
{
char c;
printf(“Size of c is %d”, sizeof c);
}

Output of this program is "Size of c is 1". Sizeof is an operator not function. So,
sizeof <variable_name> is a valid statement. But sizeof int is not. It will give
you compilation error. Better to use sizeof(<variable_name/data_type>) i.e.
enclosed in parenthesis.

43) Guess output of this C program on Macro?


#define A(x, y) cou##x##y
main()
{
int count = 12;
printf(“%d”, A(n,t));
}

Output is 12. The macro A will take two argument and paste them after word
cou. So when we called A(n,t), the macro will be replaced with count and print
the value 12. Here ## in macro pastes arguments and after replacement it ends
up with variable name not value.

44) How to use scanf to get a complete line(i.e upto '\n') from input?
Use scanf(“%[^\n]”, str). [^\n] is a regular expression that means until '\n' is
encountered.

45) Print the output of this size multiplier C program?


main()
{
struct A
{
char a;
int i;
}a;
printf("%d",sizeof(a));
}

Output will be 8. The size should be (4 + 1) or 5 but the compiler adds padding
and make its size multiple of 4.

Last Updated: Tuesday, 10 January 2017 Hits: 34376


46) Print the output of this function pointer C program?
char fun()
{
char c = 'A';
printf("Hello World");
return c;
}

main()
{
printf("%d", sizeof(fun()));
}

Output is 1. Even if this is function pointer, the sizeof will get the return type
and returns the size of that data type. Here, the return type is char, so the output
is 1.

47) Guess output or error:


#include<stdio.h>
main()
{
int a = 10, b = 20, c = 0;
printf("%d %d %.0d", a, b, c);
}

Output will be "10 20". The %.0d forces compiler to print non negative values.
As c is 0, it will not be printed.

48) Guess the condition so that neither Hello or world is printed ?


if(condition)
{
printf("Hello");
}
else
{
printf("world");
}

Condition will be fclose(stdout). It will close the stdout file handle and no
output will be printed.

49) Guess the output or error?


#include<stdio.h>
main()
{
int x = 'Aa';
printf("%#x", x);
}

Output of this program is "0x4161". The #x automatically adds 0x before the


number and prints the hexadecimal equivalent. The 'Aa' here is multi-character
assignment. It means the i will hold ascii value of these two characters in its two
bytes. Thus the output is 0x4161.

50) Guess the output of this variable initialization C program?


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

The output will be 1 2 3. The above initialization technique is unique but


allowed in C.

51) Guess the output of this C array program?


#include <stdio.h>
main()
{
int a[10] = {0,1,2,3,4,5,6,7,8,9};
printf(“%d”, 1[a]);
}

Output of this program is 1. The a[1] expression is equivalent to *(a + 1) and


1[a] is equivalent to *(1 + a). Both of them are same. So, 1[a] will return the
value of a[1].

52) Print the output of this C program using "-->" operator ?


#include <stdio.h>
main()
{
int i = 10;
while(i --> 0)
{
printf("%d ", i);
}
}

Output - 9 8 7 6 5 4 3 2 1 0. The “-->” is no new operator. Rather than it is a


trick to confuse people. The compiler will translate (i --> 0) to ((i--) > 0) as C
does not care about blank spaces. The program will start printing from 9
because of the decrement and upto 0 as this is a post increment.

53) Print the output os unassigned type C program?


#include <stdio.h>
struct A
{
unsigned int i1 : 3;
unsigned int i2 : 4;
};

main()
{
struct A a = { 15, 63};
printf("%d %d\n", a.i1, a.i2);
}

Output of this program is "7 15". The : 3 or :4 in the structure definition means
that i1 will be of unsigned int type, but it will be 3 bit long and i2 will be 4 bit
long. So, when we assign the value 15 to i1, it will only store the first 3 bits
which will result value 7. Same goes for i2. The value of i2 will be 15.

54) Guess the output of this C program using "#" Operator?


#include <stdio.h>
#define A(a,b) a##b
#define B(a) #a
#define C(a) B(a)

main()
{
printf("%s\n",C(A(1,2)));
printf("%s\n",B(A(1,2)));
}

In case of B(A(1,2)), A(1, 2) is stringize using # operator in g macro. So, the


output is A(1,2) as string. But in case of first printf, the A(1,2) is passed to
macro g but before expanding macro B, the A(1,2) macro is expanded. That is
why the output of the first printf is 12.

55) What is the difference between void foo(void) and void foo()?
Ans: In C, void foo() means a function foo taking an unspecified number of
arguments of unspecified type and void foo(void) means a function foo taking
no arguments. So, in case of void foo(), if we call this function like foo(1,2,3),
the compiler will not raise any error. But the compiler will raise an error in case
of void foo(void).

When a function is called in C, the caller pushes all of the arguments, in reverse
order, into the stack before calling the callee. Using foo() means that the
compiler won't care to check the arguments passed to foo. In case of foo(void),
before calling the function compiler will specifically check the number of
arguments and will raise an error saying the mismatch between number of
arguments.

56) Guess the output of Sizeof operator inside expression program?


#include <stdio.h>
main()
{
int i = 10;
printf("sizeof(++i) is: %d\n", sizeof(++i));
printf("i : %d\n",i);
}

Output is as given below

sizeof(++i) is: 4
i : 10

The sizeof operator is evaluated during compile time and also the expression
inside sizeof is not evaluated. The sizeof just takes the type of the expression.
Here sizeof(++i) is same as sizeof(int).

57) Print the output of this C program using Octel and Decimal?
#include <stdio.h>
main()
{
int a[] = {0001,0010,0100,1000};
int i;

for(i = 0; i < 4; i++)


{
printf("a[%d] : %d\n", i, a[i]);
}
}

Output

a[0] : 1
a[1] : 8
a[2] : 64
a[3] : 1000
The array elements are 0001,0010,0100,1000. As first three element has
preceding 0, the compiler will treat them as octal numbers. So, 0001 in octal is 1
in decimal; 0010 in octal is same as 8 in decimal and 0100 in octal is equivalent
to 64 in decimal. But the last element has no preceding 0, so the last element
will have value 1000.

58) Guess the output of C program with '!' operator?


#include<stdio.h>
main()
{
int a;
a = (int)sizeof(!2.3);
printf(“%d”, a);
}

Output is 4. The '!' operator takes an argument and return 1 if the value is 0 and
0 otherwise. So, !2.3 is 0. To sizeof 0 is an integer and so the output is 4.

59) Print the output of C program given below using strlen and sizeof
operator?
#include<string.h>
#include <stdio.h>
main()
{
printf("%d %d", sizeof("string"), strlen("string"));
}

Output is "7 6". The sizeof return the number of characters including the null
character, but strlen returns number of characters without null character.

60) Write a program to check whether a liked list is circular or not?


The following function checks whether a linked list is circular or not and return
1 if true. Otherwise it returns 0.

int IsCircular(node *head)


{
node *slow, * fast;
slow = head;
fast = head->next;
while(true)
{
if((NULL == fast) || (NULL == fast->next))
{
return 0;
}
else if((fast == slow) || (fast->next == slow))
{
return 1;
}
else
{
slow = slow->next;
fast = fast->next->next;
}
}
}

61) Guess the output of this C program having a pointer in the main
function?
#include<stdio.h>
void func(int *a)
{
int x = 1;
a = &x;
}

main()
{
int i = 2;
int *p = &i;
func(p);
printf("%d", *p);
}

Output is 2. The pointer a in function func is a local copy of pointer p. So, even
if we assign another location to a, it will not be reflected on the p in main
function. The p will point to location of i and will print 2 as result.

C Advanced Interview Questions and Answers For


Experienced Developers
C Advanced Interview Questions and Answers For Experienced
Developers
1. What is C language?
The C programming language is a standardized programming
language developed in the early 1970s by Ken Thompson and Dennis
Ritchie for use on the UNIX operating system.

It has since spread to many other operating systems, and is one of the
most widely used programming languages. C is prized for its
efficiency, and is the most popular programming language for writing
system software, though it is also used for writing applications.

2. What is the output of printf("%d")?

A. When we write printf("%d",x); this means compiler will print the


value of x. But as here, there is nothing after %d so compiler will
show in output window garbage value.
B. When we use %d the compiler internally uses it to access the
argument in the stack (argument stack). Ideally compiler determines
the offset of the data variable depending on

the format specification string. Now when we write printf("%d",a)


then compiler first accesses the top most element in the argument
stack of the printf which is %d and depending on the format string it
calculated to offset to the actual data variable in the memory which is
to be printed. Now when only %d will be present in the printf then
compiler will calculate the correct offset (which will be the offset to
access the integer variable) but as the actual data object is to be
printed is not present at that memory location so it will print what
ever will be the contents of that memory location.

C. Some compilers check the format string and will generate an error
without the proper number and type of arguments for things like
printf(...) and scanf(...).

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

1. calloc(...) allocates a block of memory for an array of elements of a


certain size. By default the block is initialized to 0. The total number
of memory allocated will be (number_of_elements * size).

malloc(...) takes in only a single argument which is the memory


required in bytes. malloc(...) allocated bytes of memory and not
blocks of memory like calloc(...).
2. malloc(...) allocates memory blocks and returns a void pointer to
the allocated space, or NULL if there is insufficient memory
available.

calloc(...) allocates an array in memory with elements initialized to 0


and returns a pointer to the allocated space. calloc(...) calls malloc(...)
in order to use the C++ set_new_mode function to set the new handler
mode.

4. What is the difference between "printf(...)" and "sprintf(...)"?

sprintf(...) writes data to the character array whereas printf(...) writes


data to the standard output device.

5. How to reduce a final size of executable?

Size of the final executable can be reduced using dynamic linking for
libraries.

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

Create two pointers, and set both to the start of the list. Update each
as follows:

while (pointer1) {
pointer1 = pointer1->next;
pointer2 = pointer2->next;
if (pointer2) pointer2=pointer2->next;
if (pointer1 == pointer2) {
print ("circular");
}}

If a list is circular, at some point pointer2 will wrap around and be


either at the item just before pointer1, or the item before that. Either
way, its either 1 or 2 jumps until they meet.

7. What is the output of the following program? Why?

#include
main() {
typedef union {
int a;
char b[10];
float c;
}
Union;
Union x,y = {100};
x.a = 50;
strcpy(x.b,"hello");
x.c = 21.50;
printf("Union x : %d %s %f n",x.a,x.b,x.c);
printf("Union y : %d %s %f n",y.a,y.b,y.c);
}

8. What does static variable mean?

There are 3 main uses for the static.

1. If you declare within a function:


It retains the value between function calls

2.If it is declared for a function name:


By default function is extern..so it will be visible from other files if
the function declaration is as static..it is invisible for the outer files

3. Static for global variables:


By default we can use the global variables from outside files If it is
static global..that variable is limited to with in the file

9. What are the advantages of a macro over a function?

Macro gets to see the Compilation environment, so it can expand __


__TIME__ __FILE__ #defines. It is expanded by the preprocessor.

For example, you can’t do this without macros


#define PRINT(EXPR) printf( #EXPR “=%d\n”, EXPR)

PRINT( 5+6*7 ) // expands into printf(”5+6*7=%d”, 5+6*7 );


You can define your mini language with macros:
#define strequal(A,B) (!strcmp(A,B))

Macros are a necessary evils of life. The purists don’t like them, but
without it no real work gets done.

10. What are the differences between malloc() and calloc()?

There are 2 differences.

First, is in the number of arguments. malloc() takes a single


argument(memory required in bytes), while calloc() needs 2
arguments(number of variables to allocate memory, size in bytes of a
single variable).

Secondly, malloc() does not initialize the memory allocated, while


calloc() initializes the allocated memory to ZERO.

11. What are the different storage classes in C?

C has three types of storage: automatic, static and allocated. Variable


having block scope and without static specifier have automatic
storage duration.

Variables with block scope, and with static specifier have static scope.
Global variables (i.e, file scope) with or without the static specifier
also have static scope.

Memory obtained from calls to malloc(), alloc() or realloc() belongs


to allocated storage class.

12. What is the difference between strings and character arrays?

A major difference is: string will have static storage duration, whereas
as a character array will not, unless it is explicity specified by using
the static keyword. Actually, a string is a character array with
following properties:

* the multibyte character sequence, to which we generally call string,


is used to initialize an array of static storage duration. The size of this
array is just sufficient to contain these characters plus the terminating
NULL character.

* it not specified what happens if this array, i.e., string, is modified.

* Two strings of same value[1] may share same memory area. For
example, in the following declarations:

char *s1 = “Calvin and Hobbes”;


char *s2 = “Calvin and Hobbes”;

The strings pointed by s1 and s2 may reside in the same memory


location. But, it is not true for the following:
char ca1[] = “Calvin and Hobbes”;
char ca2[] = “Calvin and Hobbes”;

[1] The value of a string is the sequence of the values of the contained
characters, in order.

13. What is the difference between const char* p and char const*
p?

In const char* p, the character pointed by ‘p’ is constant, so u cant


change the value of character pointed by p but u can make ‘p’ refer to
some other location.

In char const* p, the ptr ‘p’ is constant not the character referenced by
it, so u cant make ‘p’ to reference to any other location but u can
change the value of the char pointed by ‘p’.

14. What is hashing?

To hash means to grind up, and that’s essentially what hashing is all
about. The heart of a hashing algorithm is a hash function that takes
your nice, neat data and grinds it into some random-looking integer.

The idea behind hashing is that some data either has no inherent
ordering (such as images) or is expensive to compare (such as
images). If the data has no inherent ordering, you can’t perform
comparison searches.
If the data is expensive to compare, the number of comparisons used
even by a binary search might be too many. So instead of looking at
the data themselves, you’ll condense

(hash) the data to an integer (its hash value) and keep all the data with
the same hash value in the same place. This task is carried out by
using the hash value as an index into an array.

To search for an item, you simply hash it and look at all the data
whose hash values match that of the data you’re looking for. This
technique greatly lessens the number of items you have to look at. If
the parameters are set up with care and enough storage is available for
the hash table, the number of comparisons needed to find an item can
be made arbitrarily close to one.

One aspect that affects the efficiency of a hashing implementation is


the hash function itself. It should ideally distribute data randomly
throughout the entire hash table, to reduce the likelihood of collisions.
Collisions occur when two different keys have the same hash value.

There are two ways to resolve this problem. In open addressing, the
collision is resolved by the choosing of another position in the hash
table for the element inserted later. When the hash table is searched, if
the entry is not found at its hashed position in the table, the search
continues checking until either the element is found or an empty
position in the table is found.

The second method of resolving a hash collision is called chaining. In


this method, a bucket or linked list holds all the elements whose keys
hash to the same value. When the hash table is searched, the list must
be searched linearly.

15. How can you determine the size of an allocated portion of


memory?

You can’t, really. free() can , but there’s no way for your program to
know the trick free() uses. Even if you disassemble the library and
discover the trick, there’s no guarantee the trick won’t change with
the next release of the compiler.

16. Can static variables be declared in a header file?

You can’t declare a static variable without defining it as well (this is


because the storage class modifiers static and extern are mutually
exclusive). A static variable can be defined in a header file, but this
would cause each source file that included the header file to have its
own private copy of the variable, which is probably not what was
intended.

17. Can a variable be both const and volatile?

Yes. The const modifier means that this code cannot change the value
of the variable, but that does not mean that the value cannot be
changed by means outside this code.

18. Can include files be nested?


Yes. Include files can be nested any number of times. As long as you
use precautionary measures , you can avoid including the same file
twice. In the past, nesting header files was seen as bad programming
practice, because it complicates the dependency tracking function of
the MAKE program and thus slows down compilation. Many of
today’s popular compilers make up for this difficulty by
implementing a concept called precompiled headers, in which all
headers and associated dependencies are stored in a precompiled
state.

Many programmers like to create a custom header file that has


#include statements for every header needed for each module. This is
perfectly acceptable and can help avoid potential problems relating to
#include files, such as accidentally omitting an #include file in a
module.

19. When does the compiler not implicitly generate the address of
the first element of an array?

Whenever an array name appears in an expression such as

- array as an operand of the sizeof operator


- array as an operand of & operator
- array as a string literal initializer for a character array

Then the compiler does not implicitly generate the address of the
address of the first element of an array.

20. What is a null pointer?


There are times when it’s necessary to have a pointer that doesn’t
point to anything. The macro NULL, defined in , has a value that’s
guaranteed to be different from any valid pointer. NULL is a literal
zero, possibly cast to void* or char*. Some people, notably C++
programmers, prefer to use 0 rather than NULL.

The null pointer is used in three ways:

1) To stop indirection in a recursive data structure


2) As an error value
3) As a sentinel value

21. What is the difference between text and binary modes?

Streams can be classified into two types: text streams and binary
streams. Text streams are interpreted, with a maximum length of 255
characters. With text streams, carriage return/line feed combinations
are translated to the newline n character and vice versa. Binary
streams are uninterrupted and are treated one byte at a time with no
translation of characters. Typically, a text stream would be used for
reading and writing standard text files, printing output to the screen or
printer, or receiving input from the keyboard.

A binary text stream would typically be used for reading and writing
binary files such as graphics or word processing documents, reading
mouse input, or reading and writing to the modem.
22. What is static memory allocation and dynamic memory
allocation?

Static memory allocation: The compiler allocates the required


memory space for a declared variable.By using the address of
operator,the reserved address is obtained and this address may be
assigned to a pointer variable.Since most of the declared variable have
static memory,this way of assigning pointer value to a pointer variable
is known as static memory allocation. memory is assigned during
compilation time.

Dynamic memory allocation: It uses functions such as malloc( ) or


calloc( ) to get memory dynamically.If these functions are used to get
memory dynamically and the values returned by these functions are
assingned to pointer variables, such assignments are known as
dynamic memory allocation.memory is assined during run time.

23. When should a far pointer be used?

Sometimes you can get away with using a small memory model in
most of a given program. There might be just a few things that don’t
fit in your small data and code segments.

When that happens, you can use explicit far pointers and function
declarations to get at the rest of memory. A far function can be
outside the 64KB segment most functions are shoehorned into for a
small-code model. (Often, libraries are declared explicitly far, so
they’ll work no matter what code model the program uses.) A far
pointer can refer to information outside the 64KB data segment.
Typically, such pointers are used with farmalloc() and such, to
manage a heap separate from where all the rest of the data lives. If
you use a small-data, large-code model, you should explicitly make
your function pointers far.

24. How are pointer variables initialized?

Pointer variable are initialized by one of the following two ways

- Static memory allocation


- Dynamic memory allocation

25. What is the difference between arrays and pointers?

- Pointers are used to manipulate data using the address. Pointers use
* operator to access the data pointed to by them

- Arrays use subscripted variables to access and manipulate


data. Array variables can be equivalently written using pointer
expression.

26. Is using exit() the same as using return?

No. The exit() function is used to exit your program and return control
to the operating system. The return statement is used to return from a
function and return control to the calling function. If you issue a
return from the main() function, you are essentially returning control
to the calling function, which is the operating system. In this case, the
return statement and exit() function are similar.
27. What is a method?

Method is a way of doing something, especially a systematic way;


implies an orderly logical arrangement (usually in steps).

28. What is indirection?

If you declare a variable, its name is a direct reference to its value. If


you have a pointer to a variable, or any other object in memory, you
have an indirect reference to its value.

29. What is modular programming?

If a program is large, it is subdivided into a number of smaller


programs that are called modules or subprograms. If a complex
problem is solved using more modules, this approach is known as
modular programming.

30. How many levels deep can include files be nested?

Even though there is no limit to the number of levels of nested include


files you can have, your compiler might run out of stack space while
trying to include an inordinately high number of files. This number
varies according to your hardware configuration and possibly your
compiler.
31. What is the difference between declaring a variable and
defining a variable?

Declaring a variable means describing its type to the compiler but not
allocating any space for it. Defining a variable means declaring it and
also allocating space to hold the variable. You can also initialize a
variable at the time it is defined.

32. What is an lvalue?

An lvalue is an expression to which a value can be assigned. The


lvalue expression is located on the left side of an assignment
statement, whereas an rvalue is located on the right side of an
assignment statement. Each assignment statement must have an lvalue
and an rvalue. The lvalue expression must reference a storable
variable in memory. It cannot be a constant.

33. Differentiate between an internal static and external static


variable?

An internal static variable is declared inside a block with static


storage class whereas an external static variable is declared outside all
the blocks in a file.An internal static variable has persistent storage,
block scope and no linkage.An external static variable has permanent
storage,file scope and internal linkage.

34. What is the difference between a string and an array?


An array is an array of anything. A string is a specific kind of an array
with a well-known convention to determine its length. There are two
kinds of programming languages: those in which a string is just an
array of characters, and those in which it’s a special type. In C, a
string is just an array of characters (type char), with one wrinkle: a C
string always ends with a NUL character.

The “value” of an array is the same as the address of (or a pointer to)
the first element; so, frequently, a C string and a pointer to char are
used to mean the same thing.

An array can be any length. If it’s passed to a function, there’s no way


the function can tell how long the array is supposed to be, unless
some convention is used. The convention for strings is NULL
termination; the last character is an ASCII NULL (‘’) character.

35. What is an argument? Differentiate between formal


arguments and actual arguments?

An argument is an entity used to pass the data from calling function to


the called function. Formal arguments are the arguments available in
the function definition. They are preceded by their own data types.
Actual arguments are available in the function call.

36. What are advantages and disadvantages of external storage


class?

Advantages of external storage class


1)Persistent storage of a variable retains the latest value
2)The value is globally available

Disadvantages of external storage class

1)The storage for an external variable exists even when the variable is
not needed
2)The side effect may produce surprising output
3)Modification of the program is difficult
4)Generality of a program is affected

37. What is a void pointer?

A void pointer is a C convention for a raw address. The compiler has


no idea what type of object a void Pointer really points to. If you write
int *ip; ip points to an int. If you write void *p; p doesn’t point to a
void!

In C and C++, any time you need a void pointer, you can use another
pointer type. For example, if you have a char*, you can pass it to a
function that expects a void*. You don’t even need to cast it. In C (but
not in C++), you can use a void* any time you need any kind of
pointer, without casting. (In C++, you need to cast it).

A void pointer is used for working with raw memory or for passing a
pointer to an unspecified type. Some C code operates on raw memory.
When C was first invented, character pointers (char *) were used for
that. Then people started getting confused about when a character
pointer was a string, when it was a character array, and when it
was raw memory.

38. When should a type cast not be used?

A type cast should not be used to override a const or volatile


declaration. Overriding these type modifiers can cause the program to
fail to run correctly. A type cast should not be used to turn a pointer to
one type of structure or data type into another. In the rare events in
which this action is beneficial, using a union to hold the values makes
the programmer’s intentions clearer.

39. When is a switch statement better than multiple if statements?

A switch statement is generally best to use when you have more than
two conditional expressions based on a single variable of numeric
type.

40. What is a static function?

A static function is a function whose scope is limited to the current


source file. Scope refers to the visibility of a function or variable. If
the function or variable is visible outside of the current source file, it
is said to have global, or external, scope. If the function or variable is
not visible outside of the current source file, it is said to have local, or
static, scope.

41. What is a pointer variable?


A pointer variable is a variable that may contain the address of
another variable or any valid address in the memory.

42. What is a pointer value and address?

A pointer value is a data object that refers to a memory location. Each


memory location is numbered in the memory. The number attached to
a memory location is called the address of the location.

43. What is a modulus operator? What are the restrictions of a


modulus operator?

A Modulus operator gives the remainder value. The result of x%y is


obtained by (x-(x/y)*y). This operator is applied only to integral
operands and cannot be applied to float or double.

44. Differentiate between a linker and linkage?

A linker converts an object code into an executable code by linking


together the necessary build in functions. The form and place of
declaration where the variable is declared in a program determine the
linkage of variable.

45. What is a function and built-in function?

A large program is subdivided into a number of smaller programs or


subprograms. Each subprogram specifies one or more actions to be
performed for a large program. such subprograms are functions. The
function supports only static and extern storage classes. By default,
function assumes extern storage class. functions have global scope.
Only register or auto storage class is allowed in the function
parameters. Built-in functions that predefined and supplied along with
the compiler are known as built-in functions. They are also known as
library functions.

46. Why should I prototype a function?

A function prototype tells the compiler what kind of arguments a


function is looking to receive and what kind of return value a function
is going to give back. This approach helps the compiler ensure that
calls to a function are made correctly and that no erroneous type
conversions are taking place.

47. What is Polymorphism?

'Polymorphism' is an object oriented term. Polymorphism may be


defined as the ability of related objects to respond to the same
message with different, but appropriate actions. In other words,
polymorphism means taking more than one form. Polymorphism
leads to two important aspects in Object Oriented terminology -
Function Overloading and Function Overriding. Overloading is the
practice of supplying more than one definition for a given function
name in the same scope. The compiler is left to pick the appropriate
version of the function or operator based on the arguments with which
it is called.

Overriding refers to the modifications made in the sub class to the


inherited methods from the base class to change their behavior.
48. What is Operator overloading?

When an operator is overloaded, it takes on an additional meaning


relative to a certain class. But it can still retain all of its old meanings.

Examples:

1) The operators >> and << may be used for I/O operations because in
the header, they are overloaded.

2) In a stack class it is possible to overload the + operator so that it


appends the contents of one stack to the contents of another. But the +
operator still retains its original meaning relative to other types of
data.

49. What is the difference between goto and longjmp() and


setjmp()?

A goto statement implements a local jump of program execution, and


the longjmp() and setjmp() functions implement a nonlocal, or far,
jump of program execution.

Generally, a jump in execution of any kind should be avoided because


it is not considered good programming practice to use such statements
as goto and longjmp in your program.
A goto statement simply bypasses code in your program and jumps to
a predefined position. To use the goto statement, you give it a labeled
position to jump to. This predefined position must be within the same
function. You cannot implement gotos between functions.

When your program calls setjmp(), the current state of your program
is saved in a structure of type jmp_buf. Later, your program can call
the longjmp() function to restore the program’s state as it was when
you called setjmp().Unlike the goto statement, the longjmp() and
setjmp() functions do not need to be implemented in the same
function.

However, there is a major drawback to using these functions: your


program, when restored to its previously saved state, will lose its
references to any dynamically allocated memory between the
longjmp() and the setjmp(). This means you will waste memory for
every malloc() or calloc() you have implemented between your
longjmp() and setjmp(), and your program will be horribly inefficient.

It is highly recommended that you avoid using functions such as


longjmp() and setjmp() because they, like the goto statement, are
quite often an indication of poor programming practice.

S-ar putea să vă placă și