![\"Wolpertinger\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/11\/Wolpertinger.png\")
<\/p>\nA union is a particular data type where all members start at the same address. A union can hold only one type at a time; therefore, you can save memory. A tagged union is a union that keeps track of its types.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
Here are the four rules for unions.<\/p>\n
union<\/code>s to save memory<\/a><\/li>\n- C.181: Avoid \u201cnaked\u201d
union<\/code>s<\/a><\/li>\n- C.182: Use anonymous
union<\/code>s to implement tagged unions<\/a><\/li>\n- C.183: Don\u2019t use a
union<\/code> for type punning<\/a><\/li>\n<\/ul>\nLet’s start with the most obvious rule.<\/p>\n
C.180: Use union<\/code>s to save memory<\/a><\/h2>\nBecause a union can hold only one type at one point at a time, you can save memory. The union will be as big as the biggest type.<\/p>\n
<\/p>\n
<\/p>\n
\nunion<\/span> Value {\r\n int<\/span> i;\r\n double<\/span> d;\r\n};\r\n\r\nValue v =<\/span> { 123<\/span> }; \/\/ now v holds an int<\/span>\r\ncout <<<\/span> v.i <<<\/span> '\\n'<\/span>; \/\/ write 123<\/span>\r\nv.d =<\/span> 987.654<\/span>; \/\/ now v holds a double<\/span>\r\ncout <<<\/span> v.d <<<\/span> '\\n'<\/span>; \/\/ write 987.654<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
Value<\/span> is a “naked” union. You should not use it according to the next rule.<\/p>\n<\/p>\nC.181: Avoid \u201cnaked\u201d union<\/code>s<\/a><\/h2>\n“Naked” unions are error-prone because you must keep track of the underlying type.<\/p>\n
<\/p>\n
\n\/\/ nakedUnion.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nunion<\/span> Value {\r\n int<\/span> i;\r\n double<\/span> d;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n Value v;\r\n v.d =<\/span> 987.654<\/span>; \/\/ v holds a double<\/span>\r\n std::<\/span>cout <<<\/span> \"v.d: \"<\/span> <<<\/span> v.d <<<\/span> std::<\/span>endl; \r\n std::<\/span>cout <<<\/span> \"v.i: \"<\/span> <<<\/span> v.i <<<\/span> std::<\/span>endl; \/\/ (1)<\/span>\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n v.i =<\/span> 123<\/span>; \/\/ v holds an int<\/span>\r\n std::<\/span>cout <<<\/span> \"v.i: \"<\/span> <<<\/span> v.i <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \"v.d: \"<\/span> <<<\/span> v.d <<<\/span> std::<\/span>endl; \/\/ (2)<\/span>\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The union holds a double in the first iteration and an int value in the second iteration. If you read a double<\/span> as an int<\/span> (1) or an int<\/span> as a double<\/span> (2), you get undefined behavior.<\/p>\n![\"nakedUnion\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/11\/nakedUnion.png\")
<\/p>\n
To overcome this source of errors, you should use a tagged union.<\/p>\n
C.182: Use anonymous union<\/code>s to implement tagged unions<\/a><\/h2>\nImplementing a tagged union is quite sophisticated. In case you are curious, have a look at rule C.182<\/a>. I will just make it easy and will write about the new C++ standard.<\/p>\nWith C++17, we get a tagged union: std::variant<\/span>. std::variant<\/span> is a type-safe union. Here is a first impression.<\/p>\n <\/p>\n
<\/p>\n
\n\/\/ variant.cpp<\/span>\r\n\r\n#include <variant><\/span>\r\n#include <string><\/span>\r\n \r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>variant<<\/span>int<\/span>, float<\/span>><\/span> v, w; \/\/ (1)<\/span>\r\n v =<\/span> 12<\/span>; \/\/ v contains int<\/span>\r\n int<\/span> i =<\/span> std::<\/span>get<<\/span>int<\/span>><\/span>(v); \/\/ (2) <\/span>\r\n \r\n w =<\/span> std::<\/span>get<<\/span>int<\/span>><\/span>(v); \/\/ (3)<\/span>\r\n w =<\/span> std::<\/span>get<<\/span>0<\/span>><\/span>(v); \/\/ same effect as the previous line<\/span>\r\n w =<\/span> v; \/\/ same effect as the previous line<\/span>\r\n\r\n \/\/ (4)<\/span>\r\n \/\/ std::get<double>(v); \/\/ error: no double in [int, float]<\/span>\r\n \/\/ std::get<3>(v); \/\/ error: valid index values are 0 and 1<\/span>\r\n \r\n try{\r\n std::<\/span>get<<\/span>float<\/span>><\/span>(w); \/\/ w contains int, not float: will throw<\/span>\r\n }\r\n catch<\/span> (std::<\/span>bad_variant_access&<\/span>) {}\r\n \r\n \/\/ (5)<\/span>\r\n std::<\/span>variant<<\/span>std::<\/span>string><\/span> v(\"abc\"<\/span>); \/\/ converting constructors work when unambiguous<\/span>\r\n v =<\/span> \"def\"<\/span>; \/\/ converting assignment also works when unambiguous<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
In (2), I define the two variants v<\/span> and w<\/span>. Both can have an int<\/span> and a float<\/span> value. Their initial value is 0. This is the default value for the first underlying type. v<\/span> becomes 12. std::get<int>(v)<\/span> returns the value using the type. Line (3) and the following two lines show three possibilities to assign the variant v<\/span> the variant w.<\/span> But you have to keep a few rules in mind. You can ask for a variant’s value by type or index. The type must be unique and the index valid (4). If not, you will get a std::bad_variant_access<\/span> exception. <\/span>If the constructor or assignment call is unambiguous, a conversion occurs. This is why it’s possible to construct a std::variant<std::string><\/span> with a C-string or assign a new C-string to the variant (5).<\/p>\nC.183: Don\u2019t use a union<\/code> for type punning<\/a><\/h2>\nAt first, what is type punning? Type punning is the possibility of a programming language intentionally subverting the type system to treat a type as a different type. One typical way to do type punning in C++ is to read the member of a union with a different type from the one with which it was written.<\/p>\n
What is wrong with the following function bad?<\/span><\/p>\n<\/p>\n
\nunion<\/span> Pun {\r\n int<\/span> x;\r\n unsigned<\/span> char<\/span> c[sizeof<\/span>(int<\/span>)];\r\n};\r\n\r\nvoid<\/span> bad<\/span>(Pun&<\/span> u)\r\n{\r\n u.x =<\/span> 'x'<\/span>;\r\n cout <<<\/span> u.c[0<\/span>] <<<\/span> '\\n'<\/span>; \/\/ undefined behavior (1)<\/span>\r\n}\r\n\r\nvoid<\/span> if_you_must_pun<\/span>(int<\/span>&<\/span> x)\r\n{\r\n auto<\/span> p =<\/span> reinterpret_cast<\/span><<\/span>unsigned<\/span> char<\/span>*><\/span>(&<\/span>x); <\/span>\/\/ (2)<\/span><\/pre>\n<\/span> cout <<<\/span> p[0<\/span>] <<<\/span> '\\n'<\/span>; \/\/ OK; better<\/span>
\/\/ ...<\/span>
}<\/pre>\n<\/div>\n <\/p>\n
Expression (1) has two issues. First and foremost, it’s undefined behavior. Second, the type punning is quite challenging to find. If you have to use type punning, do it with an explicit cast such as reinterpret_cast <\/span>in (2). With reinterpret_cast<\/span> you have at least the possibility to spot your type punning afterwards.<\/p>\nWhat’s next?<\/h2>\n