Pointer to union

Union pointers:
What is pointer to union?
If the pointer refers to the address of the union variable, then the pointer is called  pointer to union or union pointer.
     union val {
             int ival;
             float fval;
             char cval;
     } obj, *ptr;

     ptr = &obj;

Here, pointer ptr refers to the address of the union variable obj.

How to access and assign values to union elements using pointers?
Dereference operator "->" is used to access and assign values to union using pointers.
       ptr->ival = 10;
       ptr->fval = 20.22;
       ptr->cval = 'a';
Note: Only one data member will be active at a time.
The above set of statements is equivalent to 
       (*ptr).ival = 10;
       (*ptr).fval = 20.22;
       (*ptr).cval = 'a';
Here, we have shown how to assign values to all data members of a union.  But, only one data member will be active at a time in union.  We have assigned value to (*ptr).cval recently.  So, its the current active data member in our case.

Passing union pointer as function argument

Like other data types, union pointer can also be passed as function argument.  Below program explains how to pass union pointer as function argument.

C program for pointer to union:

  #include <stdio.h>
  /* union with three different data members */
  union val {
        int ival;
        float fval;
        char cval;
  };

  /* updating data members of union using pointer */
  void update(union val *ptr, int flag) {
        if (flag == 0) {
                ptr->ival = 10;
        } else if (flag == 1) {
                ptr->fval = 10.22;
        } else {
                ptr->cval = 'z';
        }
        return;
  }

  int main() {
        int i;
        union val obj, *ptr;
        /* assigning address of union variable to pointer */
        ptr = &obj;

        for (i = 0; i < 3; i++) {
                update(ptr, i);
                /* printing the result */
                if (i == 0) {
                        printf("ptr->ival: %d\n", ptr->ival);
                } else if (i == 1) {
                        printf("ptr->fval: %.2f\n", ptr->fval);
                } else {
                        printf("ptr->cval: %c\n", ptr->cval);
                }
        }
        return 0;
  }

  Output:

  jp@jp-VirtualBox:~/$ ./a.out
  ptr->ival: 10
  ptr->fval: 10.22
  ptr->cval: z

How to return union pointer from function?
Below program explains how to return union pointer from function.

C program for union pointers:

  #include <stdio.h>
  #include <stdlib.h>
  /* union with three different data members */
  union val {
        int ival;
        float fval;
        char cval;
  };

  /* updates data members of union and returns a pointer to union */
  union val * update(int flag) {
        union val *ptr;
        /* dynamic memory allocation for union */
        ptr = (union val *)malloc(sizeof(union val));

        /* updating values for union data members */
        if (flag == 0) {
                ptr->ival = 10;
        } else if (flag == 1) {
                ptr->fval = 10.22;
        } else {
                ptr->cval = 'z';
        }
        return(ptr);
  }

  int main() {

        int i;

        union val *ptr;

        for (i = 0; i < 3; i++) {

                ptr = update(i);

                /* printing the result */

                if (i == 0) {

                        printf("ptr->ival: %d\n", ptr->ival);

                } else if (i == 1) {

                        printf("ptr->fval: %.2f\n", ptr->fval);

                } else {

                        printf("ptr->cval: %c\n", ptr->cval);

                }

                /* releasing the memory */

                free(ptr);

        }

        return 0;

  }

  Output:

  jp@jp-VirtualBox:~/$ ./a.out
  ptr->ival: 10
  ptr->fval: 10.22
  ptr->cval: z

Dynamic memory allocation for union:
Let us see how to perform dynamic memory allocation for a union.
     union val {
             int ival;
             float fval;
             char cval;
     } *ptr;
    ptr = (union val *)malloc(sizeof(union val));

The above statement performs dynamic memory allocation for a union object using pointers.