union在析构时，怎么知道当初使用的是哪个成员？

bruceteen

问题在代码的注释中

1. #include <string>
   
2. #include <vector>
   
3. 
   
4. union foo
   
5. {
   
6.     std::vector<int> a;
   
7.     std::string b;
   
8.    
   
9.     foo() : a({1,2,3})
   
10.     {
    
11.     }
    
12.     foo( int ) : b("123")
    
13.     {
    
14.     }
    
15.     ~foo()
    
16.     {
    
17.         // 它怎么知道应该析构a，还是析构b？
    
18.     }
    
19.    
    
20. };
    
21. 
    
22. #include <iostream>
    
23. using namespace std;
    
24. 
    
25. int main( void )
    
26. {
    
27.     foo f1;
    
28.     foo f2( 1 );
    
29.    
    
30.     return 0;
    
31. }

复制代码

如上，f1和f2使用同一个析构函数，那么这个析构函数怎么知道f1应该析构a，f2应该析构b？

hellioncu

union还可以这样玩啊

cokeboL

城里人真会玩

如果需要手动释放成员，就手动加个 flag 标记需要释放哪个吧。。

windoze

no you don't

union就是这样，所以要么你加个tag让它变成tagged union，要么你就干脆直接用boost::variant或者我的C++11增强版variant

folklore

用VC试了， VC什么都不调用

1. class A1 {
   
2. public:
   
3.         A1() {
   
4. 
   
5.         }
   
6.          ~A1() {
   
7.                 printf("A*11111* dead");
   
8.         }
   
9. };
   
10. 
    
11. class A2 {
    
12. public:
    
13.         ~A2() {
    
14.                 printf("A*2222* dead");
    
15.         }
    
16. };
    
17. 
    
18. 
    
19. 
    
20. int main()
    
21. {
    
22.         union un
    
23.         {
    
24.                 A1 a1;
    
25.                 A2 a2;
    
26. 
    
27.                 un() : a1() {
    
28. 
    
29.                 }
    
30. 
    
31.                 un(int) : a2() {
    
32. 
    
33.                 }
    
34. 
    
35.                 ~un() {
    
36. 
    
37.                 }
    
38.         };
    
39. 
    
40.         {
    
41.                 un u1;
    
42.                
    
43.         }
    
44. 
    
45.         {
    
46.                 un u1(0);
    
47.         }
    
48. 
    
49.         printf("ttt");
    
50.     return 0;
    
51. }
    

复制代码

输出 ttt

nswcfd

g++ 4.4干脆不允许有析构函数的联合成员。

hevake_lcj

union还能这么玩