【C言語】 共用体の使い方入門｜メモリ効率・注意点までサンプル付き解説

struct Point {
    int x;
    int y;
};

union Number {
    int   i;
    float f;
};

struct S {
    int   i;       // 4バイト想定
    double d;      // 8バイト想定
    char  text[16];// 16バイト
};

union U {
    int   i;       // 4バイト想定
    double d;      // 8バイト想定
    char  text[16];// 16バイト
};

union タグ名 {
    型1 メンバ名1;
    型2 メンバ名2;
    /* ... */
} 変数名1, 変数名2;

#include <stdio.h>

union Data {
    int   i;     // 整数としてのメンバ
    float f;     // 浮動小数点としてのメンバ
    char  c;     // 1文字としてのメンバ
};

int main(void) {
    // union Data 型の変数を宣言
    union Data d;

    // int として代入
    d.i = 100;
    printf("d.i = %d\n", d.i);

    // float として代入
    d.f = 3.14f;
    printf("d.f = %f\n", d.f);

    // char として代入
    d.c = 'A';
    printf("d.c = %c\n", d.c);

    return 0;
}

#include <stdio.h>

union Value {
    int   i;
    float f;
};

int main(void) {
    union Value v;       // 値そのもの
    union Value *pv = &v;// ポインタ

    v.i = 42;            // ドット演算子でアクセス
    printf("v.i = %d\n", v.i);

    pv->f = 1.5f;        // アロー演算子でアクセス
    printf("v.f = %f\n", pv->f);

    return 0;
}

// パターン1: タグ名 + typedef名
typedef union Number {
    int   i;
    float f;
} Number;

// パターン2: タグなし、typedefのみ
typedef union {
    int   i;
    float f;
} Number2;

#include <stdio.h>

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

int main(void) {
    Number n; // unionを意識せずに使える

    n.i = 10;
    printf("n.i = %d\n", n.i);

    n.f = 2.5f;
    printf("n.f = %f\n", n.f);

    return 0;
}

#include <stdio.h>

typedef enum {
    VALUE_INT,
    VALUE_FLOAT,
    VALUE_CHAR
} ValueKind;

// データ本体は共用体で表現
typedef union {
    int   i;
    float f;
    char  c;
} ValueData;

// どのメンバが有効かを示すタグ付き構造体
typedef struct {
    ValueKind kind; // 有効な型の情報
    ValueData data; // 実際の値(共用体)
} TaggedValue;

void print_value(TaggedValue v) {
    switch (v.kind) {
    case VALUE_INT:
        printf("INT: %d\n", v.data.i);
        break;
    case VALUE_FLOAT:
        printf("FLOAT: %f\n", v.data.f);
        break;
    case VALUE_CHAR:
        printf("CHAR: %c\n", v.data.c);
        break;
    default:
        printf("UNKNOWN\n");
        break;
    }
}

int main(void) {
    TaggedValue v1 = { VALUE_INT,   { .i = 123 } };
    TaggedValue v2 = { VALUE_FLOAT, { .f = 4.56f } };
    TaggedValue v3 = { VALUE_CHAR,  { .c = 'X' } };

    print_value(v1);
    print_value(v2);
    print_value(v3);

    return 0;
}

#include <stdio.h>
#include <stdint.h>

// int と float のビット表現を比較するための共用体
typedef union {
    int32_t i;
    float   f;
    uint8_t bytes[4]; // 1バイト単位でも見られる
} IntFloatUnion;

void print_bits(const uint8_t *bytes, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        // 上位ビットから順に出力
        for (int bit = 7; bit >= 0; --bit) {
            putchar( (bytes[i] & (1u << bit)) ? '1' : '0' );
        }
        putchar(' ');
    }
    putchar('\n');
}

int main(void) {
    IntFloatUnion u;

    u.f = 1.0f; // float として代入
    printf("u.f = %f\n", u.f);
    printf("u.i = %d\n", u.i);
    printf("bytes : ");
    print_bits(u.bytes, sizeof(u.bytes));

    u.i = 0x3f800000; // IEEE754 で 1.0f に対応するビット列
    printf("u.i = 0x%08x\n", u.i);
    printf("u.f = %f\n", u.f);
    printf("bytes : ");
    print_bits(u.bytes, sizeof(u.bytes));

    return 0;
}

#include <stdio.h>
#include <stdint.h>

// 32ビットレジスタを、ビット/バイト/整数として見る共用体
typedef union {
    uint32_t value; // 32ビット値としてアクセス

    struct {
        uint32_t flag0 : 1;
        uint32_t flag1 : 1;
        uint32_t flag2 : 1;
        uint32_t flag3 : 1;
        uint32_t reserved : 28;
    } bits;          // フラグとしてアクセス(ビットフィールド)

    uint8_t bytes[4];// バイト配列としてアクセス
} Reg32;

int main(void) {
    Reg32 reg = { 0 };

    // ビットフィールドでフラグを設定
    reg.bits.flag0 = 1;
    reg.bits.flag2 = 1;

    printf("value = 0x%08x\n", reg.value);
    printf("bytes = %02x %02x %02x %02x\n",
           reg.bytes[0], reg.bytes[1],
           reg.bytes[2], reg.bytes[3]);

    // 直接 value に書き込む
    reg.value = 0x0000000f;
    printf("flag0 = %u\n", reg.bits.flag0);
    printf("flag1 = %u\n", reg.bits.flag1);
    printf("flag2 = %u\n", reg.bits.flag2);
    printf("flag3 = %u\n", reg.bits.flag3);

    return 0;
}

#include <stdio.h>
#include <stdint.h>

typedef union {
    uint32_t value;
    uint8_t  bytes[4];
} EndianCheck;

int main(void) {
    EndianCheck e;
    e.value = 0x01020304;

    printf("value = 0x%08x\n", e.value);
    printf("bytes = %02x %02x %02x %02x\n",
           e.bytes[0], e.bytes[1],
           e.bytes[2], e.bytes[3]);

    if (e.bytes[0] == 0x04) {
        printf("Little endian\n");
    } else if (e.bytes[0] == 0x01) {
        printf("Big endian\n");
    } else {
        printf("Unknown endian\n");
    }

    return 0;
}

#include <stdio.h>
#include <stdint.h>

typedef struct {
    uint8_t a;
    uint8_t b;
    uint8_t c;
} SStruct;

typedef union {
    uint8_t a;
    uint8_t b;
    uint8_t c;
} SUnion;

int main(void) {
    printf("sizeof(SStruct) = %zu\n", sizeof(SStruct));
    printf("sizeof(SUnion)  = %zu\n", sizeof(SUnion));

    SStruct s = { .a = 1, .b = 2, .c = 3 };
    SUnion  u = { .a = 1 };

    printf("Struct: a=%u, b=%u, c=%u\n", s.a, s.b, s.c);

    printf("Union(before): a=%u, b=%u, c=%u\n", u.a, u.b, u.c);
    u.b = 5; // 同じ1バイトを上書き
    printf("Union(after b=5): a=%u, b=%u, c=%u\n", u.a, u.b, u.c);

    return 0;
}

union U {
    int   i;
    float f;
};

union U u;
u.i = 123;
printf("%f\n", u.f); // 規格上は未定義動作

#include <stdio.h>

union AlignTest {
    char  c;   // 通常は1バイト境界
    int   i;   // 多くの環境で4バイト境界
    float f;   // 多くの環境で4バイト境界
};

int main(void) {
    printf("sizeof(AlignTest) = %zu\n", sizeof(union AlignTest));
    return 0;
}