Find Output Of Program

Question 1 :

What will be the output of the program?

#include < stdio . h >
int main()
{
    char far *near *ptr1;
    char far *far *ptr2;
    char far *huge *ptr3;
    printf("%d, %d, %d\n", sizeof(ptr1), sizeof(ptr2), sizeof(ptr3));
    return 0;
}


A). 4, 4, 8
B). 4, 4, 4
C). 2, 4, 4
D). 2, 4, 8
Answer : Option C

Question 2 :

What will be the output of the program in DOS (Compiler - Turbo C)?

#include < stdio . h >
double i;
int main()
{
    (int)(float)(char) i;
    printf("%d", sizeof((int)(float)(char)i));
    return 0;
}


A). 1
B). 2
C). 4
D). 8
Answer : Option B

Explanation :

Due to the C language is being platform dependent:
In Turbo C (DOS - 16 bit platform), the output will be 2.
But in GCC (Unix/Linux - 32 bit platform), the output will be 4.


Question 3 :

What will be the output of the program?

#include < stdio . h >
int main()
{
    char huge *near *far *ptr1;
    char near *far *huge *ptr2;
    char far *huge *near *ptr3;
    printf("%d, %d, %d\n", sizeof(**ptr1), sizeof(ptr2), sizeof(*ptr3));
    return 0;
}


A). 4, 4, 4
B). 2, 2, 2
C). 2, 8, 4
D). 2, 4, 8
Answer : Option A

Question 4 :

What will be the output of the program (in Turbo C under DOS)?

#include < stdio . h >

int main()
{
    char huge *near *far *ptr1;
    char near *far *huge *ptr2;
    char far *huge *near *ptr3;
    printf("%d, %d, %d\n", sizeof(ptr1), sizeof(ptr2), sizeof(ptr3));
    return 0;
}


A). 4, 4, 8
B). 2, 4, 4
C). 4, 4, 2
D). 2, 4, 8
Answer : Option C

Question 5 :

What will be the output of the program?

#include < stdio . h >
typedef void v;
typedef int i;

int main()
{
    v fun(i, i);
    fun(2, 3);
    return 0;
}
v fun(i a, i b)
{
    i s=2;
    float i;
    printf("%d,", sizeof(i));
    printf(" %d", a*b*s);
}


A). 2, 8
B). 4, 8
C). 2, 4
D). 4, 12
Answer : Option D

Question 6 :

What will be the output of the program?

#include < stdio . h >

int main()
{
    char huge *near *far *ptr1;
    char near *far *huge *ptr2;
    char far *huge *near *ptr3;
    printf("%d, %d, %d\n", sizeof(ptr1), sizeof(*ptr2), sizeof(**ptr3));
    return 0;
}


A). 4, 4, 4
B). 2, 4, 4
C). 4, 4, 2
D). 2, 4, 8
Answer : Option A

Question 7 :

What will be the output of the program?

#include < stdio . h >
typedef unsigned long int uli;
typedef uli u;

int main()
{
    uli a;
    u b = -1;
    a = -1;
    printf("%lu, %lu", a, b);
    return 0;
}


A). 4343445454, 4343445454
B). 4545455434, 4545455434
C). 4294967295, 4294967295
D). Garbage values
Answer : Option C

Explanation :

The system will treat the negative numbers with 2's complement method.

For 'long int' system will occupy 4 bytes (32 bits).

Therefore,
Binary 1 : 00000000 00000000 00000000 00000001
To represent -1, system uses the 2's complement value of 1. Add 1 to the 1's complement result to obtain 2's complement of 1.

So, First take 1's complement of binary 1 (change all 0s to 1s and all 1s to 0s)
1's complement of Binary 1:
11111111 11111111 11111111 11111110
2's complement of Binary 1: (Add 1 with the above result)
11111111 11111111 11111111 11111111
In HexaDecimal
11111111 11111111 11111111 11111111 = FFFF FFFF FFFF FFFF
In Unsigned Integer
11111111 11111111 11111111 11111111 = 4294967295.


Question 8 :

What will be the output of the program in DOS (Compiler - Turbo C)?

#include < stdio . h >
double i;

int main()
{
    (int)(float)(char) i;
    printf("%d",sizeof(i));
    return 0;
}


A). 4
B). 8
C). 16
D). 22
Answer : Option B

Question 9 :

What will be the output of the program under DOS?

#include < stdio . h >
int main()
{
    char huge *near *far *ptr1;
    char near *far *huge *ptr2;
    char far *huge *near *ptr3;
    printf("%d, %d, %d\n", sizeof(ptr1), sizeof(**ptr2), sizeof(ptr3));
    return 0;
}


A). 4, 4, 4
B). 4, 2, 2
C). 2, 8, 4
D). 2, 4, 8
Answer : Option B

Question 10 :

What will be the output of the program?

#include < stdio . h >
int main()
{
    struct s1
    {
        char *z;
    int i;
    struct s1 *p;
    };
    static struct s1 a[] = {{"Nagpur", 1, a+1} , {"Chennai", 2, a+2} , 
                            {"Bangalore", 3, a} };

    struct s1 *ptr = a;
    printf("%s,", ++(ptr->z));
    printf(" %s,", a[(++ptr)->i].z);
    printf(" %s", a[--(ptr->p->i)].z);
    return 0;
}


A). Nagpur, Chennai, Bangalore
B). agpur, hennai, angalore
C). agpur, Chennai, angalore
D). agpur, Bangalore, Bangalore
Answer : Option D

Question 11 :

What will be the output of the program?

#include < stdio . h >
int main()
{
    char huge *near *ptr1;
    char huge *far *ptr2;
    char huge *huge *ptr3;
    printf("%d, %d, %d\n", sizeof(ptr1), sizeof(ptr2), sizeof(ptr3));
    return 0;
}


A). 4, 4, 8
B). 2, 4, 4
C). 4, 4, 2
D). 2, 4, 8
Answer : Option B

Question 12 :

What will be the output of the program in Turbo C?

#include < stdio . h >
int main()
{
    char near *near *ptr1;
    char near *far *ptr2;
    char near *huge *ptr3;
    printf("%d, %d, %d\n", sizeof(ptr1), sizeof(ptr2), sizeof(ptr3));
    return 0;
}


A). 4, 4, 8
B). 4, 4, 4
C). 2, 4, 8
D). 2, 4, 4
Answer : Option D