タグ付き共用体（Tagged Union）とは？仕組みと具体例をわかりやすく解説

// 値の種類を表すタグ(列挙型)
typedef enum {
    VALUE_INT,
    VALUE_DOUBLE,
    VALUE_STRING
} ValueType;

// 実際のデータを格納する共用体
typedef union {
    int    i;
    double d;
    char   s[32];
} ValueData;

// タグ付き共用体
typedef struct {
    ValueType type; // どのメンバが有効かを示すタグ
    ValueData data; // 実際のデータ(共用体)
} TaggedValue;

#include <stdio.h>

typedef union {
    int   i;
    float f;
} IntOrFloat;

int main(void) {
    IntOrFloat v;

    v.i = 10; // int として格納
    printf("as int   : %d\n", v.i);
    printf("as float : %f\n", v.f); // 同じメモリを float として読む(意味不明な値になる可能性)

    v.f = 3.14f; // float として格納
    printf("as int   : %d\n", v.i); // 今度は逆に int として読む

    return 0;
}

#include <stdio.h>
#include <string.h>

// 値の種類(タグ)を表す列挙型
typedef enum {
    VALUE_INT,
    VALUE_DOUBLE,
    VALUE_STRING
} ValueType;

// 実データを格納する共用体
typedef union {
    int    i;
    double d;
    char   s[32];
} ValueData;

// タグ付き共用体
typedef struct {
    ValueType type; // どのメンバが有効か
    ValueData data;
} TaggedValue;

// int 値を設定する関数
void set_int(TaggedValue *v, int x) {
    v->type = VALUE_INT;  // タグを設定
    v->data.i = x;        // 実データを設定
}

// double 値を設定する関数
void set_double(TaggedValue *v, double x) {
    v->type = VALUE_DOUBLE;
    v->data.d = x;
}

// 文字列を設定する関数
void set_string(TaggedValue *v, const char *s) {
    v->type = VALUE_STRING;
    strncpy(v->data.s, s, sizeof(v->data.s) - 1);
    v->data.s[sizeof(v->data.s) - 1] = '\0'; // 終端を保証
}

#include <stdio.h>
#include <string.h>

typedef enum {
    VALUE_INT,
    VALUE_DOUBLE,
    VALUE_STRING
} ValueType;

typedef union {
    int    i;
    double d;
    char   s[32];
} ValueData;

typedef struct {
    ValueType type;
    ValueData data;
} TaggedValue;

void print_value(const TaggedValue *v) {
    switch (v->type) {
    case VALUE_INT:
        printf("INT: %d\n", v->data.i);
        break;
    case VALUE_DOUBLE:
        printf("DOUBLE: %f\n", v->data.d);
        break;
    case VALUE_STRING:
        printf("STRING: %s\n", v->data.s);
        break;
    default:
        printf("UNKNOWN TYPE\n");
        break;
    }
}

int main(void) {
    TaggedValue a, b, c;

    // int を設定
    a.type = VALUE_INT;
    a.data.i = 42;

    // double を設定
    b.type = VALUE_DOUBLE;
    b.data.d = 3.14159;

    // 文字列を設定
    b.type = VALUE_DOUBLE;
    b.data.d = 3.14159;

    c.type = VALUE_STRING;
    strncpy(c.data.s, "Hello", sizeof(c.data.s) - 1);
    c.data.s[sizeof(c.data.s) - 1] = '\0';

    print_value(&a);
    print_value(&b);
    print_value(&c);

    return 0;
}

#include <stdio.h>
#include <math.h>

typedef enum {
    RESULT_OK,
    RESULT_ERROR
} ResultTag;

typedef union {
    double value;     // 成功時の結果
    int    error_code; // 失敗時のエラーコード
} ResultData;

typedef struct {
    ResultTag tag;
    ResultData data;
} TaggedResult;

// 正の数の平方根を計算し、負の数ならエラーにする
TaggedResult safe_sqrt(double x) {
    TaggedResult r;
    if (x < 0.0) {
        r.tag = RESULT_ERROR;
        r.data.error_code = -1; // 負の数エラー
    } else {
        r.tag = RESULT_OK;
        r.data.value = sqrt(x);
    }
    return r;
}

int main(void) {
    TaggedResult r1 = safe_sqrt(4.0);
    TaggedResult r2 = safe_sqrt(-1.0);

    if (r1.tag == RESULT_OK) {
        printf("sqrt(4.0) = %f\n", r1.data.value);
    } else {
        printf("sqrt(4.0) error: %d\n", r1.data.error_code);
    }

    if (r2.tag == RESULT_OK) {
        printf("sqrt(-1.0) = %f\n", r2.data.value);
    } else {
        printf("sqrt(-1.0) error: %d\n", r2.data.error_code);
    }

    return 0;
}

void print_value_safe(const TaggedValue *v) {
    switch (v->type) {
    case VALUE_INT:
        printf("INT: %d\n", v->data.i);
        break;
    case VALUE_DOUBLE:
        printf("DOUBLE: %f\n", v->data.d);
        break;
    case VALUE_STRING:
        printf("STRING: %s\n", v->data.s);
        break;
    default:
        // ここに来るのはおかしいのでデバッグ用メッセージ
        printf("ERROR: invalid tag (%d)\n", v->type);
        break;
    }
}