Union and Memory Allocation in C
Memory Allocation
You can allocate memory for unions using two methods:
- Static memory allocation
- Dynamic memory allocation
Static memory allocation
In this method, the memory for the union is allocated at compile-time.
This method is suitable when the size of the union is fixed and known at compile-time.
Syntax
union union_name {
// union members
};
int main() {
union union_name u; // static memory allocation
// use union members
return 0;
}
Example
#include <stdio.h>
// define a union type named "my_union"
union my_union
{
int i;
float f;
char c;
};
int main()
{
union my_union u; // allocate memory for the union statically
u.i = 42; // set the value of the "int" member
printf("The value of the integer member is %d\n", u.i);
u.f = 3.14; // set the value of the "float" member
printf("The value of the float member is %f\n", u.f);
u.c = 'A'; // set the value of the "char" member
printf("The value of the char member is %c\n", u.c);
printf("The value of the integer member is %d\n",
u.i); // accessing the "int" member after setting the "char" member
// overwrites its value
return 0;
}
Output:
Explanation:
- We define a union type named
my_union
that has three members: an integer namedi
, a float namedf
, and a character namedc
. - In the
main
function, we declare a variableu
of typemy_union
, which allocates memory for the union statically. - We then set the value of the
int
member to 42 using thedot notation
, and print its value. - We then set the value of the
float
member to 3.14 using thedot notation
, and print its value. - We then set the value of the
char
member to 'A' using the dot notation, and print its value.
note
- Note that when we set the value of the
char
member, it overwrites the value of theint
member, since a union can hold only one member at a time. - Thus, when we print the value of the
int
member again, we get the value that was last set in the union.
Dynamic memory allocation
In this method, the memory for the union is allocated at run-time.
This method is suitable when the size of the union is not fixed and known only at run-time.
Syntax
union union_name {
// union members
};
int main() {
union union_name *u = (union union_name*) malloc(sizeof(union union_name)); // dynamic memory allocation
// use union members
free(u); // free memory when done
return 0;
}
Explanation
- We use the
malloc()
function to allocate memory for the union. - The
sizeof()
operator is used to get the size of the union, which is then passed as an argument tomalloc()
. - We cast the return value of
malloc()
to the type of the union to ensure that the pointer returned bymalloc()
points to a block of memory of the correct size. - When we are done using the union, we must free the memory allocated by calling the
free()
function.
Example
#include <stdio.h>
#include <stdlib.h> // include the standard library header for malloc() and free()
// define a union type named "my_union"
union my_union
{
int i;
float f;
char c;
};
int main()
{
union my_union *u = (union my_union *)malloc(
sizeof(union my_union)); // allocate memory for the union dynamically
u->i = 42; // set the value of the "int" member using the arrow notation
printf("The value of the integer member is %d\n", u->i);
u->f = 3.14; // set the value of the "float" member using the arrow notation
printf("The value of the float member is %f\n", u->f);
u->c = 'A'; // set the value of the "char" member using the arrow notation
printf("The value of the char member is %c\n", u->c);
printf("The value of the integer member is %d\n",
u->i); // accessing the "int" member after setting the "char" member
// overwrites its value
free(u); // free the memory allocated for the union
return 0;
}
Output:
Explanation:
- We define a union type named
my_union
that has three members: an integer namedi
, a float namedf
, and a character namedc
. - In the
main
function, we declare a pointer variableu
of typemy_union
, which will point to the block of memory allocated for the union dynamically. - We use the
malloc()
function to allocate memory for the union dynamically. - We pass the size of the union, which is obtained using the
sizeof()
operator, as an argument tomalloc()
. - We cast the return value of
malloc()
to the type of the union to ensure that the pointer returned bymalloc()
points to a block of memory of the correct size. - We then set the value of the
int
member to 42 using the arrow notation, and print its value. - We then set the value of the
float
member to 3.14 using the arrow notation, and print its value. - We then set the value of the
char
member to 'A' using the arrow notation, and print its value. - Finally, we use the
free()
function to free the memory allocated for the union when we are done using it.
note
- Note that when we set the value of the
char
member, it overwrites the value of theint
member, since a union can hold only one member at a time. - Thus, when we print the value of the "int" member again, we get the value that was last set in the union.
Comparion
Comparison table of static memory allocation and dynamic memory allocation for a union:
Property | Static memory allocation | Dynamic memory allocation |
---|---|---|
Memory allocation | Memory for the union is allocated at compile time | Memory for the union is allocated at run time |
Memory size | The memory size of the union is fixed and determined by its definition | The memory size of the union can be determined at run time by the programmer |
Lifetime | The memory for the union exists throughout the entire program execution | The memory for the union can be allocated and freed during program execution |
Access | Access to union members is done using the dot notation or the arrow notation | Access to union members is done using the pointer notation and the arrow notation |
Initialization | Union members can be initialized at compile time | Union members can be initialized at run time using the arrow notation |
Flexibility | Static memory allocation provides less flexibility as the size of the union is fixed | Dynamic memory allocation provides more flexibility as the size of the union can be changed during program execution |
tip
- The choice between static memory allocation and dynamic memory allocation for a union depends on the specific requirements of the program.
- If the size of the union is fixed and known at compile time, then static memory allocation can be a good choice.
- If the size of the union is not fixed or needs to be determined at run time, then dynamic memory allocation may be a better choice.