C/C++ union 使用教程

强制类型转换

C/C++ 为我们提供了强制类型转换，使得我们可以把一块内存看成int，看成double......

例如下面的代码，我们有个4个字节的数组，然后告诉编译器。

请把 data 看成一个int* 的指针，并且往里面写入值。

char data[4];
*(int*)data = 114514;
cout << *(int*)data << endl;
*(float*)data = 1919.810;
cout << *(float*)data << endl;

输出

114514
1919.81

也就是，data[4] 用来保存了int和float ，当然了不能同时存在。

union介绍

而C语言本身就提供了一个类似的东西。

union U
{
    int x;
    float y;
};

int main()
{
    U u;
    u.x = 114;
    cout << u.x << endl;
    u.y = 5.14;
    cout << u.y << endl;
}

输出

114
5.14

实际上就是两个变量共用同一块内存。

如果是多个变量的话，union的大小就为最大的那一个变量。

union U1
{
    int x;
    float y;
    double z;
};
union U2
{
    int arr[10];
    double z;
};

int main()
{
    cout << sizeof(U1) << endl;
    cout << sizeof(U2) << endl;
}

当然，我们也可以union里面放个结构体。里面的结构体是需要满足内存对齐的。

union U
{
    struct node
    {
        int x;
        long long y;
    }u;
    double z;
};
int main()
{
    cout << sizeof(U) << endl;
    cout << sizeof(U::node) << endl;
}

输出

16
16

---

union查看内存分布

比如，我想看看一个int的数，或者一个结构体，其内存中的样子。

我们就可以利用union

union U
{
    unsigned char bits[4];
    int num;
};


int main()
{
    U x;
    x.num = 64;
    for (int i = 0; i < 4; i++) {
        cout<<bitset<8>(x.bits[i]) << " ";
    }
    cout << endl;
    x.num = 114514;
    for (int i = 0; i < 4; i++) {
        cout << bitset<8>(x.bits[i]) << " ";
    }
}

输出

01000000 00000000 00000000 00000000
01010010 10111111 00000001 00000000

结构体同理。

union优化短字符串

在字符串中，一般情况下比较相等，我们都是通过比较哈希值的。

而有些库中，对于长度比较短的字符串是有单独的优化的。

比如对于长度小于等于8的短字符串。可以这样

struct short_str
{
    union 
    {
        unsigned long long hs;
        char s[8];
    };
};

这里我们用到了匿名union，就是不给这个union名字，但是还是可以访问到数据

然后

int main()
{
    short_str s;
    memcpy(s.s, "hello", 6);
    cout << s.s << endl;
    cout << s.hs << endl;
}

输出

hello
14757170557546685800

我们可以快速的获得短字符串的哈希值(把这个ull看成哈希值)，就能快速的比较两个短字符串是否相等了。

union取别名

在一些二维的问题中，一般都是，定义点，然后点构成了线。

struct point {
    int x, y;
};
struct line {
    point p1, p2;
};

如果我们需要访问具体的数据就要 name.p1.x 这样，比较麻烦。

但我们可以利用union

struct point{
    int x, y;
};
struct line{
    union {
        struct {
            point p1, p2;
        };
        int arr[4];
    };
};
int main()
{
    line L = {114,514,1919,810};
    cout << L.p1.x << " " << L.p1.y << endl;
    for (int i = 0; i < 4; i++)L.arr[i] = i;
    cout << L.p1.x << " " << L.p1.y << endl;
    cout << L.p2.x << " " << L.p2.y << endl;
    cout << sizeof(line) << endl;
}

输出

114 514
0 1
2 3
16

union实现简易的动态类型

利用union我们可以轻易的写出一个简单的动态类型

struct var{
    union {
        int iv;
        double dv;
        char* sv;
    };
    var(const int& v) :iv{ v } {};
    var(const double& v) :dv{ v } {};
    var(const char* s) {
        int len = strlen(s);
        sv = new char[len + 1];
        memcpy(sv, s, len + 1);
    }
};
int main()
{
    var x = 1415;
    cout << x.iv << endl;
    x = 3.14;
    cout << x.dv << endl;
    x = "hello world";
    cout << x.sv << endl;
}

输出

1415
3.14
hello world

 

union的缺点

感觉很对是吧，但是如果你如果细心就会发现

我们没有释放new出来的内存

这三个值共享一块内存，如果是int，double那还好都在这里

我们没有释放char*指向的内存

也就是后面可能这块内存，后面又变成了int，变成了double，然后又指向了一块new出来的内存

你可以说，那我手动释放呗

那就没意思了。

我们希望实现，union自己就释放内存，也就是可以自动的析构。

显然原生的union做不到这一点，这就是为什么，不推荐union里面塞有析构函数的东西。

但是C++17中引入一个variant ，它可以实现和union类似的效果，并且会自动析构。