C Programming - Declarations and Initializations - Discussion

Discussion Forum : Declarations and Initializations - Find Output of Program (Q.No. 10)
10.
What is the output of the program?
#include<stdio.h>
int main()
{
    union a
    {
        int i;
        char ch[2];
    };
    union a u;
    u.ch[0] = 3;
    u.ch[1] = 2;
    printf("%d, %d, %d\n", u.ch[0], u.ch[1], u.i);
    return 0;
}
3, 2, 515
515, 2, 3
3, 2, 5
None of these
Answer: Option
Explanation:

printf("%d, %d, %d\n", u.ch[0], u.ch[1], u.i); It prints the value of u.ch[0] = 3, u.ch[1] = 2 and it prints the value of u.i means the value of entire union size.

So the output is 3, 2, 515.

Discussion:
77 comments Page 1 of 8.

Mostafa Hamoda said:   7 years ago
Guys let's take it easy.

The function of the union is to calculate the size of each of the variable contained in it and find the biggest size of them and then create a place on memory of that size, so in this example a 4 bytes space of memory is reserved for our union, in our usage we created an object (u) which have access to our four bytes, our first assignment was to put a value of 3(u.ch[0]) in the first byte because our array is of type character so our object will deal with only the first byte and initialize the rest of them with (zeros), and the second byte with 2 (u.ch[1]) now in our memory we should have a shape like this:

00000000 00000000 00000010 00000011
(ch[1]) (ch[0])
[ ONE INTEGER].

Now, when we used our object to access the memory and deal with info side as if it were an integer.

So the value would be (1*2^0+1*2^2+1*2^9) = 515.
(3)

Sumith said:   6 years ago
Why would the "i" get the entire size of union?
(2)

Shaziya Hasan said:   5 years ago
How can we use %d for a character array? Can anyone explain?
(1)

Manjiree said:   6 years ago
Please can you explain in detail how it will calculate the entire size of the union?
(1)

Anonymous said:   10 years ago
"printf("%d, %d, %d\n", u.ch[0], u.ch[1], u.i);

It prints the value of u.ch[0] = 3, u.ch[1] = 2 and it prints the value of u.i means the value of entire union size." is the explanation by the indiabix.

The last words 'value of entire union size' doesn't means size of the union rather the value represented when entire union is considered as integer of 2 bytes.

Bit confusing. C stores the information in 0s and 1s,

When one say, "Hey! will you please store an int for me" for a machine with int size 2 byte will store the binary equivalent of that number in 2 bytes for example to store decimal 2 it will store 00000000 in 1st byte and 00000010 in second byte, at time of retrieval C will read 2 consecutive bytes change it into decimal and will output it for you.

When one say, "Hey! will you please store a character for me. "Machine will reserve 1 byte of memory and store ascii value of the character in that one byte. For example if character is 'a' ASCII value 65 (Binary:- 01000001) is stored in that byte. At time of retrieval the ASCII code will be changed to corresponding character.

In the case we are discussing the char1 and char0 are stored at memory location say 2000 and 2001, at time of reading (when printf ("%d", u.i) ) , an integer is read at location 2000 (yes, the beauty of union!) and C reads the 2 bytes 2000 and 2001 that are 00000011 and 00000010 c combines it to make 0000000100000011 which is binary for 515.
(1)

Ishu said:   10 years ago
Why value of u?

I means the entire size of union? Can someone help me out?

Sanju said:   9 years ago
Every time I run the program, it didn't give 515 for me. It's giving some garbage value. Please help me.

Nidhi bhardwaj said:   9 years ago
But why are assuming that "i" will have size of union and not garbage value?

Because as I have studied about union, the most recent allocation is given the memory and rest all have garbage.

Kavya said:   9 years ago
How/why we get 512 and 515? Please explain me.

Punya said:   9 years ago
Please check by running the same program with c compiler, the Garbage value will be printed for i.


Post your comments here:

Your comments will be displayed after verification.