{"id":7783,"date":"2026-10-10T00:01:42","date_gmt":"2026-10-10T07:01:42","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=7783"},"modified":"2026-10-03T14:23:09","modified_gmt":"2026-10-03T21:23:09","slug":"tagging-a-union","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=7783","title":{"rendered":"Tagging a Union"},"content":{"rendered":"

A union by itself presents some issues, which is why unions are flagged as insecure. I’ve shown some examples in last week’s Lesson<\/a>. But there is a solution that provides a backstop for consistency when accessing the different data types stored as union members.
\n
\nI received a few slaps on LinkedIn when I shared the “Back When Unions Were Useful”<\/a> post a few weeks back. Apparently, modern C code still uses a union in many instances. Active C programmers descended upon my post with ample vigor. The key that keeps a union usable and necessary is that the union’s data must be tagged<\/em>.<\/p>\n

The process of tagging a union involves coordinating a union’s contents with an enumerated list of data types. The list of data types determines how the union’s data is accessed. As an example, consider this union:<\/p>\n

union values {
\n    char ch[8];
\n    long li;
\n};<\/code><\/p>\n

The values<\/em> union has storage for char<\/em> variable ch<\/code> as an 8-character array or string. Also present is a long int<\/em>, li<\/code>. Both of these items share their storage, which is a point of contention.<\/p>\n

To tag these items, an enumerated list is coupled to the union. In the enumeration, the data types are represented as constant values:<\/p>\n

enum {
\n    TYPE_STRING,
\n    TYPE_LONG
\n};<\/code><\/p>\n

The enum<\/em> keyword creates two constants, TYPE_STRING<\/code> and TYPE_LONG<\/code>. These constants are assigned values 0 and 1 by the compiler, which is how enumeration works<\/a>. The point is to relate these constants to the union’s data types. This pairing is creates the tags.<\/p>\n

The enum and the union are married within a structure: the constants are the tags, and the union’s data is the payload. This design keeps data aligned, with the tags serving as a reference to ensure that the proper values stored in the union are recognized. The following code shows an example:<\/p>\n

2026_10_10-Lesson.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <string.h>\r\n\r\n\/* tagged union definition *\/<\/span>\r\nstruct u_data {\r\n    \/* tags *\/<\/span>\r\n    enum {\r\n        TYPE_STRING,\r\n        TYPE_LONG\r\n    } data_type;\r\n    \/* payload *\/<\/span>\r\n    union values {\r\n        char ch[8];\r\n        long li;\r\n    } v;\r\n};\r\n\r\n\/* generate output based on tag *\/<\/span>\r\nvoid output(struct u_data d)\r\n{\r\n    switch(d.data_type)\r\n    {\r\n        case TYPE_STRING:\r\n            printf(\"String value is: %s\\n\",d.v.ch);\r\n            break;\r\n        case TYPE_LONG:\r\n            printf(\"Long int value: %li\\n\",d.v.li);\r\n            break;\r\n        default:\r\n            printf(\"Unknown data type\\n\");\r\n    }\r\n}\r\n\r\nint main()\r\n{\r\n    struct u_data data;\r\n\r\n    \/* set data type tag and data *\/<\/span>\r\n    data.data_type = TYPE_STRING;\r\n    strcpy(data.v.ch,\"Hello!\");\r\n\r\n    \/* output proper data *\/<\/span>\r\n    output(data);\r\n\r\n    return 0;\r\n}<\/pre>\n
The code starts with the tagged union structure definition. The u_data<\/em> structure contains enumerated constants data_type<\/em> and union values<\/em>. The constant names in the enumeration pair with the data types stored in the union.<\/p>\n
The output()<\/em> function swallows a u_data<\/em> structure as its argument, referenced as d<\/code> within the function. A switch-case<\/em> structure evaluates the d.data_type<\/code> member in the structure, which reflects the enumerated constant for the data type requested. Each case<\/em> statement matches the data types. A printf(<\/em>) statement outputs the data properly based on the tag presented:<\/p>\n