Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

An anonymous union is an unnamed union defined within a structure or another union that lacks both a tag name and an instance identifier. Standardized in C11, it allows its members to be accessed directly as if they were members of the enclosing parent type, while still sharing the same overlapping memory space characteristic of a standard union.

​
Syntax and Declaration

To declare an anonymous union, the union keyword is used without a tag and without a declarator at the end of the block. 
struct ParentStruct {
    int type_identifier;
    
    // Anonymous Union
    union {
        int as_integer;
        float as_float;
        char* as_string;
    }; 
};

​
Member Access and Scope Injection

The primary mechanical feature of an anonymous union is scope injection. The compiler promotes the members of the anonymous union into the namespace of the enclosing structure. Given the declaration above, the members are accessed directly via the parent structure instance, bypassing any intermediate union name: 
struct ParentStruct obj;

// Direct access to anonymous union members
obj.as_integer = 42;
obj.as_float = 3.14f;
If the union were named (e.g., union { ... } data;), access would require traversing the identifier: obj.data.as_integer.

​
Memory Layout

The memory semantics remain identical to a standard union. All members within the anonymous union occupy the same memory location.
  • The offset of as_integer, as_float, and as_string relative to the base address of ParentStruct is identical.
  • The total size contributed by the anonymous union to the parent structure is determined by its largest member (e.g., char* as_string on a 64-bit architecture), plus any alignment padding required by the ABI.
  • Writing to one member of the anonymous union overwrites the memory space, invalidating the values of the other members within that same anonymous block.

​
Technical Restrictions

  1. Standardization: Anonymous unions are strictly part of the ISO C11 standard (-std=c11). In C99 and earlier, they were only supported via compiler-specific extensions (such as -fms-extensions in GCC/Clang).
  2. Nesting Context: An anonymous union must be a member of a struct or another union. It cannot be declared at file scope or block scope as a standalone entity.
  3. No Tag or Typedef: It cannot possess a tag name (union TagName { ... };), nor can it be combined with a typedef in its immediate declaration, as both would violate the definition of being anonymous.
  4. Namespace Collisions: Because members are injected into the parent’s scope, the identifiers inside the anonymous union must not conflict with any other member names in the enclosing struct or union. The following will result in a compilation error:
struct InvalidStruct {
    int as_integer; // Conflict
    
    union {
        int as_integer; // Error: duplicate member
        float as_float;
    };
};
Master C with Deep Grasping Methodology!Learn More