c++ - C++ union 是如何知道其中存储的类型以及调用哪个析构函数的？

Question

使用两个类的union，在这个简单的示例中，union 记住了最后一个存储在其中的类，并为该对象调用正确的析构函数:

#include <iostream>

using std::cout;
using std::endl;

struct yes{
    yes(){cout<<"yes-c"<<endl;}
    ~yes(){cout<<"yes-d"<<endl;}
};
struct no{
    no(){cout<<"no-c"<<endl;}
    ~no(){cout<<"no-d"<<endl;}
};
struct u{
    union{
        yes y;
        no n;
    };
    u(yes _y):y(_y){}
    u(no _n):n(_n){}        
    ~u(){}
};


int main() {
    yes y;
    no n;
    {
    u uu(n);
    }

    return 0;
}

输出:

yes-c
no-c
no-d
no-d
yes-d

所以uu会为union调用正确的析构函数~no()，就好像它记录了构造union时的类型。这是如何运作的？

Answer 1

简短的回答:不是。

如果你给 no 添加一个拷贝构造函数你会看到实际上有三个 no正在创建对象，但只有两个被破坏。

首先创建对象 n .然后，当您将它按值 传递给 u 时构造函数，它被复制一次到 _n争论。那_n然后将对象复制到 uu.n 中成员(member)。

破坏属于_n u 中的参数构造函数，以及 n main 中的对象功能。

---

这是您的程序，稍作修改以添加复制构造函数并跟踪 no对象:

#include <iostream>

struct yes{
    yes(){std::cout<<"yes-c"<<std::endl;}
    ~yes(){std::cout<<"yes-d"<<std::endl;}
};
struct no{
    no(){std::cout<<"no-c : "<<n<<std::endl;}
    no(no const& o)
        : n(o.n + 1)
    {
        std::cout << "no-cc : " << o.n << " -> " << n << '\n';
    }

    ~no(){std::cout<<"no-d : "<<n<<std::endl;}
    int n = 0;
};
struct u{
    union{
        yes y;
        no n;
    };
    u(yes _y):y(_y){}
    u(no _n):n(_n){}
    ~u(){}
};

int main()
{
    yes y;
    no n;
    {
        u uu(n);
    }
}

如果没有优化或复制省略，这将创建输出

yes-cno-c : 0no-cc : 0 -> 1no-cc : 1 -> 2no-d : 1no-d : 0yes-d

输出 no-c : 0用于创建 n main 中的对象功能。

输出 no-cc : 0 -> 1用于复制到 u构造函数参数 _n .

输出 no-cc : 1 -> 2用于复制参数 _n进入 union n对象。

输出 no-d : 1是_n的破坏争论。

输出 no-d : 0是n的破坏main 中的对象功能。