C programming Language Interview Questions and Answers

Predict the output or error(s) for the following:

63.     main()
{
                        int i=4,j=7;
            j = j || i++ && printf("YOU CAN");
                        printf("%d %d", i, j);
}
 
Answer:
4 1 

Explanation:
The boolean expression needs to be evaluated only till the truth value of the expression is not known. j is not equal to zero itself means that the expression’s truth value is 1. Because it is followed by || and true || (anything) => true where (anything) will not be evaluated. So the remaining expression is not evaluated and so the value of i remains the same.
Similarly when && operator is involved in an expression, when any of the operands become false, the whole expression’s truth value becomes false and hence the remaining expression will not be evaluated.     
            false && (anything) => false where (anything) will not be evaluated.

64.    main()
{
                        register int a=2;
            printf("Address of a = %d",&a);
                        printf("Value of a   = %d",a);
}

Answer:
Compier Error: '&' on register variable
Rule to Remember:
                         & (address of ) operator cannot be applied on register variables.

65.     main()
{
                        float i=1.5;
            switch(i)
                        {
                        case 1: printf("1");
                                    case 2: printf("2");
                                    default : printf("0");
            }
}

Answer:
Compiler Error: switch expression not integral

Explanation:
Switch statements can be applied only to integral types.

66.     main()
{          
                        extern i;
            printf("%d\n",i);
                        {
                                    int i=20;
                        printf("%d\n",i);
                        }
}

Answer:
Linker Error : Unresolved external symbol i

Explanation:
The identifier i is available in the inner block and so using extern has no use in resolving it.

67.       main()
{
                        int a=2,*f1,*f2;
            f1=f2=&a;
                        *f2+=*f2+=a+=2.5;
            printf("\n%d %d %d",a,*f1,*f2);
}

Answer:
16 16 16

Explanation:
f1 and f2 both refer to the same memory location a. So changes through f1 and f2 ultimately affects only the value of a.

68.     main()
{
                        char *p="GOOD";
            char a[ ]="GOOD";
printf("\n sizeof(p) = %d, sizeof(*p) = %d, strlen(p) = %d", sizeof(p), sizeof(*p), strlen(p));
            printf("\n sizeof(a) = %d, strlen(a) = %d", sizeof(a), strlen(a));
}

Answer:
                        sizeof(p) = 2, sizeof(*p) = 1, strlen(p) = 4
            sizeof(a) = 5, strlen(a) = 4

Explanation:
                        sizeof(p) => sizeof(char*) => 2
            sizeof(*p) => sizeof(char) => 1
                        Similarly,
            sizeof(a) => size of the character array => 5
When sizeof operator is applied to an array it returns the sizeof the array and it is not the same as the sizeof the pointer variable. Here the sizeof(a) where a is the character array and the size of the array is 5 because the space necessary for the terminating NULL character should also be taken into account.

69.     #define DIM( array, type) sizeof(array)/sizeof(type)
main()
{
int arr[10];
printf(“The dimension of the array is %d”, DIM(arr, int));    
}

Answer:
10   

Explanation:
The size  of integer array of 10 elements is 10 * sizeof(int). The macro expands to sizeof(arr)/sizeof(int) => 10 * sizeof(int) / sizeof(int) => 10.

70.     int DIM(int array[]) 
{
return sizeof(array)/sizeof(int );
}
main()
{
int arr[10];
printf(“The dimension of the array is %d”, DIM(arr));    
}

Answer:
1   

Explanation:
Arrays cannot be passed to functions as arguments and only the pointers can be passed. So the argument is equivalent to int * array (this is one of the very few places where [] and * usage are equivalent). The return statement becomes, sizeof(int *)/ sizeof(int) that happens to be equal in this case.

71.    main()
{
            static int a[3][3]={1,2,3,4,5,6,7,8,9};
            int i,j;
            static *p[]={a,a+1,a+2};
                        for(i=0;i<3;i++) j="0;j<3;j++)">

                                   printf("%d\t%d\t%d\t%d\n",*(*(p+i)+j),
                                    *(*(j+p)+i),*(*(i+p)+j),*(*(p+j)+i));
                        }
}

Answer:
                                    1       1       1       1
                                    2       4       2       4
                                    3       7       3       7
                                    4       2       4       2
                                    5       5       5       5
                                    6       8       6       8
                                    7       3       7       3
                                    8       6       8       6
                                    9       9       9       9
Explanation:
                        *(*(p+i)+j) is equivalent to p[i][j].