Cast operator ()

Cast expression syntax

>>-(--type--)--expression--------------------------------------><

The following example demonstrates the use of the cast operator to dynamically create an integer array of size 10:

#include <stdlib.h>

int main(void) {
   int* myArray = (int*) malloc(10 * sizeof(int));
   free(myArray);
   return 0;
}

The malloc library function returns a void pointer that points to memory that holds an object of the size of its argument. The statement int* myArray = (int*) malloc(10 * sizeof(int)) has the following steps:

• Creates a void pointer that points to memory that can hold ten integers.
• Converts that void pointer into an integer pointer with the use of the cast operator.
• Assigns that integer pointer to myArray.

Only a type that explicitly exists as a member of a union type can be cast to that union type. The cast can use either the tag of the union type or a union type name declared in a typedef expression. The type specified must be a complete union type. An anonymous union type can be used in a cast to a union type, provided that it has a tag or type name. A bit field can be cast to a union type, provided that the union contains a bit field member of the same type, but not necessarily of the same length. The following code shows an example of a simple cast to union:

#include <stdio.h>

union f {
   char t;
   short u;
   int v;
   long w;
   long long x;
   float y;
   double z;
};

int main() {
  union f u;
  char a = 1;
  u = (union f)a;
  printf("u = %i\n", u.t);
} 

The output of this example is:

u = 1

Casting to a nested union is also allowed. In the following example, the double type dd can be cast to the nested union u2_t.

int main() {
   union u_t {
      char a;
      short b;
      int c;
      union u2_t {
         double d;
      }u2;
   };
   union u_t U;
   double dd = 1.234;
   U.u2 = (union u2_t) dd;      // Valid.
   printf("U.u2 is %f\n", U.u2);
}

The output of this example is:

U.u2 is 1.234

A union cast is also valid as a function argument, part of a constant expression for initialization of a static or non-static data object, and in a compound literal statement. The following example shows a cast to union used as part of an expression for initializing a static object:

struct S{
  int a;
}s;

union U{
  struct S *s;
};

struct T{
  union U u;
};

static struct T t[] = { {(union U)&s} };