Pointers - C Interview Questions and Answers

Why "C Programming - Pointers" Interview Questions?

In this section you can learn and practice interview questions based on ""C Programming - Pointers"" and improve your skills in order to face the interview, competitive examination and various entrance tests (CAT, GATE, GRE, MAT, Bank Exam, Railway Exam etc.) with full confidence.

Where can I get "C Programming - Pointers" interview questions and answers with explanation?

IndiaBIX provides you lots of fully solved "C Programming - Pointers" interview questions and answers with Explanation. All students, freshers can download "C Programming - Pointers" quiz questions with answers as PDF files and eBooks. Solved examples with detailed answer description, explanation are given and it would be easy to understand. View the solution for the problems with feel and good user interface; easily go through all questions and answers.

How to answer "C Programming - Pointers" interview questions?

You can easily answer the interview questions based on "C Programming - Pointers" by practicing the exercises given below.

  1. 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. If p is a pointer, the value of p is the address of the object. *p means "apply the indirection operator to p"; its value is the value of the object that p points to. (Some people would read it as "Go indirect on p.")

    *p is an lvalue; like a variable, it can go on the left side of an assignment operator, to change the value. If p is a pointer to a constant, *p is not a modifiable lvalue; it can't go on the left side of an assignment.

    Consider the following program. It shows that when p points to i, *p can appear wherever i can.

    #include <stdio.h>
    int main()
    {
            int i;
            int *p;
            i = 5;
            p = & i;    /* now *p == i */
            printf("i=%d, p=%P, *p=%d\n", i, p, *p);
            *p = 6;     /* same as i = 6 */
            printf("i=%d, p=%P, *p=%d\n", i, p, *p);
            return 0;
    }
    

    After p points to i (p = &i), you can print i or *p and get the same thing. You can even assign to *p, and the result is the same as if you had assigned to i.

  2. How many levels of pointers can you have?

    The answer depends on what you mean by "levels of pointers." If you mean "How many levels of indirection can you have in a single declaration?" the answer is "At least 12."

    int i = 0;

    int *ip01 = & i;

    int **ip02 = & ip01;

    int ***ip03 = & ip02;

    int ****ip04 = & ip03;

    int *****ip05 = & ip04;

    int ******ip06 = & ip05;

    int *******ip07 = & ip06;

    int ********ip08 = & ip07;

    int *********ip09 = & ip08;

    int **********ip10 = & ip09;

    int ***********ip11 = & ip10;

    int ************ip12 = & ip11;

    ************ip12 = 1; /* i = 1 */

    If you mean "How many levels of pointer can you use before the program gets hard to read," that's a matter of taste, but there is a limit. Having two levels of indirection (a pointer to a pointer to something) is common. Any more than that gets a bit harder to think about easily; don't do it unless the alternative would be worse.

    If you mean "How many levels of pointer indirection can you have at runtime," there's no limit. This point is particularly important for circular lists, in which each node points to the next. Your program can follow the pointers forever.

    Consider the following program "A circular list that uses infinite indirection".

    /* Would run forever if you didn't limit it to MAX */
    #include <stdio.h>
    struct circ_list
    {
            char    value[ 3 ];     /* e.g., "st" (incl '\0') */
            struct circ_list        *next;
    };
    struct circ_list    suffixes[] = {
            "th", & suffixes[ 1 ], /* 0th */
            "st", & suffixes[ 2 ], /* 1st */
            "nd", & suffixes[ 3 ], /* 2nd */
            "rd", & suffixes[ 4 ], /* 3rd */
            "th", & suffixes[ 5 ], /* 4th */
            "th", & suffixes[ 6 ], /* 5th */
            "th", & suffixes[ 7 ], /* 6th */
            "th", & suffixes[ 8 ], /* 7th */
            "th", & suffixes[ 9 ], /* 8th */
            "th", & suffixes[ 0 ], /* 9th */
            };
    #define MAX 20
    int main()
    {
         int i = 0;
         struct circ_list    *p = suffixes;
         while (i <= MAX) 
         {
                 printf( "%d%s\n", i, p->value );
                 ++i;
                 p = p->next;
         }
         return 0;
    }
    

    Each element in suffixes has one suffix (two characters plus the terminating NUL character) and a pointer to the next element. next is a pointer to something that has a pointer, to something that has a pointer, ad infinitum.

    The example is dumb because the number of elements in suffixes is fixed. It would be simpler to have an array of suffixes and to use the i%10'th element. In general, circular lists can grow and shrink.