”;
Anonymous Structures and Unions in C
The feature of anonymous structures and unions was introduced in C11 standard. The aim was to enhance the flexibility of C and also to discard the need of superfluous naming in certain cases.
The feature of defining struct and union anonymously has been found to be extremely useful, especially in applications involving the creation of complex data structures, hardware register mappings, etc. This allows for more straightforward and readable code.
Anonymous Structure
An anonymous structure is a structure definition without a tag or a typedef. It is usually nested within another struct.
Syntax for Anonymous Struct
Here is the syntax of defining an anonymous structure −
struct type { elem1; elem2; struct { elem3; elem4; }; };
Access Members of Anonymous Structure
Members of an anonymous struct/union can access the parent struct directly, simplifying the notation.
Example 1
In the code below, we have defined a structure with the name as employee. Inside it, an anonymous struct is intended to hold date, month and year of birth of the employee. In the example on nested structure, we had an internal dob structure. Now we’ll use anonymous struct.
#include <stdio.h> struct employee { char name[10]; float salary; struct { int d, m, y; }; }; int main(){ struct employee e1; strcpy (e1.name, "Kiran"); e1.salary=25000; e1.d = 12; e1.m = 5; e1.y = 1990; printf("Name: %sn", e1.name); printf("Salary: %fn", e1.salary); printf("Date of Birth: %d-%d-%dn", e1.d, e1.m, e1.y); return 0; }
Output
When you run this code, it will produce the following output −
Name: Kiran Salary: 25000.000000 Date of Birth: 12-5-1990
Note that the “d”, “m” and “y” elements of inner anonymous struct are accessed directly.
Example 2
The outer struct type in the following example is student, which has a nested anonymous struct to store the title and ID of the course.
#include <stdio.h> struct student { char name[10]; int age; struct { char coursettl[20]; int courseid; }; }; int main(){ struct student s1; strcpy (s1.name, "Kiran"); s1.age = 27; strcpy(s1.coursettl, "C Programming"); s1.courseid=1; printf("Name: %sn", s1.name); printf("age: %dn", s1.age); printf("Course Title: %s Course ID: %dn", s1.coursettl, s1.courseid); return 0; }
Output
When you run this code, it will produce the following output −
Name: Kiran age: 27 Course Title: C Programming Course ID: 1
Anonymous Union
An anonymous union is a special type of union that doesn”t have a name. Unlike regular unions, anonymous unions are primarily used to create unnamed members that can be accessed directly without qualifying them with a union name.
Syntax for Anonymous Union
Here is the syntax of defining an anonymous union −
struct type { elem1; elem2; union { elem3; elem4; }; };
Access Members of Anonymous Union
The members of the anonymous union can be accessed directly without using a union name.
Example
Anonymous unions do not have a name. The elements share the same memory location.
Take a look at the following example −
#include <stdio.h> struct mystruct { int var; union { int var1; float var2; char var3; }; }; int main(){ struct mystruct data; data.var = 10; data.var2 = 5.55; printf("mystruct.var: %dn", data.var); printf("anonymous union elements: %d %f %c", data.var1, data.var2, data.var3); return 0; }
Output
Run the code and check its output −
mystruct.var: 10 anonymous union elements: 1085381018 5.550000 �
Note: Like a regular union, the uninitialized members of an anonymous union variable also show garbage value.
Advantages of Anonymous Struct and Union
One of the main advantages is the ability to access the members directly without any inner struct or union name. This can make the code more readable. Here is a list of some other advantages of using anonymous structures and unions −
- Memory Efficiency − Like regular unions, anonymous unions allow different data types to share the same memory space, leading to more memory-efficient code, especially useful in low-memory environments.
- Flexibility − Anonymous structures provide flexibility in how data is represented and accessed, allowing for more dynamic and versatile data structures.
- Convenience − This feature allows for a compact representation of a variable that can hold different data types.
- Ease of Initialization − They can be easier to initialize and use, as they do not require the declaration of a union variable.
Note that anonymous struct or union types were not part of the C standard before C11. Hence, their use in the code may lead to compatibility problems, if the target system uses a compiler compliant with earlier standards.
”;