什么时候有人会使用工会？这是纯 C 时代的残余吗？
我学到了，但并没有真正加入工会。我读过的每本 C 或 C++ 文本都会介绍它们（有时是顺便介绍），但它们往往很少给出关于为什么或在哪里使用它们的实际示例。工会何时在现代（甚至遗留）情况下有用？我唯一的两个猜测是，当您的工作空间非常有限时，或者当您正在开发 API（或类似的东西）并且您希望强制最终用户在以下位置仅拥有多个对象/类型的一个实例时，对微处理器进行编程：一度。这两个猜测是否接近正确？
I have learned but don't really get unions. Every C or C++ text I go through introduces them (sometimes in passing), but they tend to give very few practical examples of why or where to use them. When would unions be useful in a modern (or even legacy) case? My only two guesses would be programming microprocessors when you have very limited space to work with, or when you're developing an API (or something similar) and you want to force the end user to have only one instance of several objects/types at one time. Are these two guesses even close to right?
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（18）
联合在处理字节级（低级）数据时很有用。
我最近的使用之一是 IP 地址建模，如下所示：
Unions are useful when dealing with byte-level (low level) data.
One of my recent usage was on IP address modeling which looks like below :
联合在 C 中提供多态性。
Unions provide polymorphism in C.
我使用联合的一个例子：
这允许我以数组或元素的形式访问数据。
我使用联合让不同的术语指向相同的值。在图像处理中，无论我是在处理列、宽度还是 X 方向的尺寸，都可能会变得令人困惑。为了缓解这个问题，我使用了联合，这样我就知道哪些描述是在一起的。
An example when I've used a union:
this allows me to access my data as an array or the elements.
I've used a union to have the different terms point to the same value. In image processing, whether I was working on columns or width or the size in the X direction, it can become confusing. To alleve this problem, I use a union so I know which descriptions go together.
union关键字虽然仍在 C++031 中使用，但主要是 C 时代的残余。最明显的问题是它仅适用于 POD1。然而，联合体的想法仍然存在，并且确实 Boost 库具有类似联合体的类：
它具有联合体的大部分优点（如果不是全部的话），并增加了
在实践中，已经证明它相当于
union+enum的组合，并且经过基准测试，它的速度一样快（而boost::any更多的是dynamic_cast的领域，因为它使用 RTTI）。1C++11 中的联合已升级 (不受限制的联合），现在可以包含带有析构函数的对象，尽管用户必须手动调用析构函数（在当前活动的联合成员上）。使用变体仍然要容易得多。
The
unionkeyword, while still used in C++031, is mostly a remnant of the C days. The most glaring issue is that it only works with POD1.The idea of the union, however, is still present, and indeed the Boost libraries feature a union-like class:
Which has most of the benefits of the
union(if not all) and adds:In practice, it has been demonstrated that it was equivalent to a combination of
union+enum, and benchmarked that it was as fast (whileboost::anyis more of the realm ofdynamic_cast, since it uses RTTI).1Unions were upgraded in C++11 (unrestricted unions), and can now contain objects with destructors, although the user has to invoke the destructor manually (on the currently active union member). It's still much easier to use variants.
一个例子是在嵌入式领域，其中寄存器的每一位可能意味着不同的东西。例如，8 位整数和具有 8 个独立的 1 位位域的结构的并集允许您更改一位或整个字节。
One example is in the embedded realm, where each bit of a register may mean something different. For example, a union of an 8-bit integer and a structure with 8 separate 1-bit bitfields allows you to either change one bit or the entire byte.
赫伯·萨特在 GOTW 大约六年前，添加了强调：
对于不太有用的示例，请参阅冗长但不确定的问题 gcc, strict - 别名，并通过联合进行转换。
Herb Sutter wrote in GOTW about six years ago, with emphasis added:
And for a less useful example, see the long but inconclusive question gcc, strict-aliasing, and casting through a union.
嗯，我能想到的一个示例用例是这样的：
然后您可以访问该 32 位数据块的 8 位单独部分；然而，请做好可能被字节序所影响的准备。
这只是一个假设的示例，但每当您想要将字段中的数据拆分为这样的组成部分时，您都可以使用并集。
也就是说，还有一种字节序安全的方法：
例如，因为二进制运算将由编译器转换为正确的字节序。
Well, one example use case I can think of is this:
You can then access the 8-bit separate parts of that 32-bit block of data; however, prepare to potentially be bitten by endianness.
This is just one hypothetical example, but whenever you want to split data in a field into component parts like this, you could use a union.
That said, there is also a method which is endian-safe:
For example, since that binary operation will be converted by the compiler to the correct endianness.
联合的一些用途：
Grep 包含文件以供编译器使用。您会发现
union有数十到数百种用途：Some uses for unions:
Saving storage space when fields are dependent on certain values:
Grep the include files for use with your compiler. You'll find dozens to hundreds of uses of
union:我发现 C++ 联合非常酷。似乎人们通常只考虑想要“就地”更改联合实例的值的用例（这似乎仅用于节省内存或执行可疑的转换）。
事实上，联合作为一种软件工程工具具有强大的威力，即使您从不更改任何联合实例的值。
用例 1：变色龙
通过联合，您可以将多个任意类重新组合到一个名称下，这与基类及其派生类的情况并非没有相似之处。然而，改变的是对于给定的联合实例可以做什么和不能做什么：
程序员在想要使用给定联合实例时似乎必须确定其内容的类型。上面的函数
f就是这种情况。然而，如果一个函数接收一个联合实例作为传递的参数，就像上面的 g 的情况一样，那么它不知道如何处理它。这同样适用于返回联合实例的函数，请参阅h：调用者如何知道里面有什么？如果联合实例永远不会作为参数或返回值传递，那么它的生活必然非常单调，当程序员选择更改其内容时，会感到兴奋不已：
这是最（不）流行的用例工会。另一个用例是联合实例附带一些可以告诉您其类型的信息。
用例 2：“很高兴认识你，我是来自
Class的object”假设程序员选择始终将联合实例与类型描述符配对（I'将由读者自行想象一个这样的对象的实现）。如果程序员想要节省内存并且类型描述符的大小相对于联合的大小不可忽略，那么这就违背了联合本身的目的。但我们假设联合实例可以作为参数或返回值传递，而被调用者或调用者不知道里面的内容，这一点至关重要。
然后程序员必须编写一个
switch控制流语句来告诉 Bruce Wayne 与木棍或类似的东西不同。当联合体中只有两种类型的内容时，这还不算太糟糕，但显然，联合体不再可扩展。用例 3：
作为 ISO C++ 标准建议的作者< /a> 把它放回 2008 年，
现在，举一个带有 UML 类图的示例：
简单英语的情况：一个对象类 A 可以 具有 B1、...、Bn 中任何类的对象，并且每种类型最多一个，其中 n 至少是一个相当大的数字10.
我们不想像这样向 A 添加字段（数据成员）：
因为 n 可能会有所不同（我们可能希望将 Bx 类添加到混合中），并且因为这会导致混乱使用构造函数，因为 A 对象会占用大量空间。
我们可以使用一个古怪的容器，其中包含指向
Bx对象的指针，并进行强制转换来检索它们，但这很丑陋，而且是 C 风格的……但更重要的是，这会留下我们需要管理许多动态分配对象的生命周期。相反，可以做的是：
然后，要从
data获取联合实例的内容，您可以使用a.get(TYPE_B2).b2等，其中a是类A实例。由于联合在 C++11 中不受限制，这一点更加强大。请参阅上面链接的文档或这篇文章了解详细信息。
I find C++ unions pretty cool. It seems that people usually only think of the use case where one wants to change the value of a union instance "in place" (which, it seems, serves only to save memory or perform doubtful conversions).
In fact, unions can be of great power as a software engineering tool, even when you never change the value of any union instance.
Use case 1: the chameleon
With unions, you can regroup a number of arbitrary classes under one denomination, which isn't without similarities with the case of a base class and its derived classes. What changes, however, is what you can and can't do with a given union instance:
It appears that the programmer has to be certain of the type of the content of a given union instance when he wants to use it. It is the case in function
fabove. However, if a function were to receive a union instance as a passed argument, as is the case withgabove, then it wouldn't know what to do with it. The same applies to functions returning a union instance, seeh: how does the caller know what's inside?If a union instance never gets passed as an argument or as a return value, then it's bound to have a very monotonous life, with spikes of excitement when the programmer chooses to change its content:
And that's the most (un)popular use case of unions. Another use case is when a union instance comes along with something that tells you its type.
Use case 2: "Nice to meet you, I'm
object, fromClass"Suppose a programmer elected to always pair up a union instance with a type descriptor (I'll leave it to the reader's discretion to imagine an implementation for one such object). This defeats the purpose of the union itself if what the programmer wants is to save memory and that the size of the type descriptor is not negligible with respect to that of the union. But let's suppose that it's crucial that the union instance could be passed as an argument or as a return value with the callee or caller not knowing what's inside.
Then the programmer has to write a
switchcontrol flow statement to tell Bruce Wayne apart from a wooden stick, or something equivalent. It's not too bad when there are only two types of contents in the union but obviously, the union doesn't scale anymore.Use case 3:
As the authors of a recommendation for the ISO C++ Standard put it back in 2008,
And now, an example, with a UML class diagram:
The situation in plain English: an object of class A can have objects of any class among B1, ..., Bn, and at most one of each type, with n being a pretty big number, say at least 10.
We don't want to add fields (data members) to A like so:
because n might vary (we might want to add Bx classes to the mix), and because this would cause a mess with constructors and because A objects would take up a lot of space.
We could use a wacky container of
void*pointers toBxobjects with casts to retrieve them, but that's fugly and so C-style... but more importantly that would leave us with the lifetimes of many dynamically allocated objects to manage.Instead, what can be done is this:
Then, to get the content of a union instance from
data, you usea.get(TYPE_B2).b2and the likes, whereais a classAinstance.This is all the more powerful since unions are unrestricted in C++11. See the document linked to above or this article for details.
联合通常与鉴别器一起使用：一个指示联合的哪些字段有效的变量。例如，假设您想创建自己的 Variant 类型：
那么您将使用它，例如：
这实际上是一个非常常见的习惯用法，特别是在 Visual Basic 内部。
有关真实示例，请参阅 SDL 的 SDL_Event union。 （此处的实际源代码）。联合顶部有一个
type字段，并且每个 SDL_*Event 结构上都会重复相同的字段。然后，要处理正确的事件，您需要检查type字段的值。好处很简单：有一种数据类型可以处理所有事件类型，而无需使用不必要的内存。
Unions are usually used with the company of a discriminator: a variable indicating which of the fields of the union is valid. For example, let's say you want to create your own Variant type:
Then you would use it such as:
This is actually a pretty common idiom, specially on Visual Basic internals.
For a real example see SDL's SDL_Event union. (actual source code here). There is a
typefield at the top of the union, and the same field is repeated on every SDL_*Event struct. Then, to handle the correct event you need to check the value of thetypefield.The benefits are simple: there is one single data type to handle all event types without using unnecessary memory.
最近，严格别名规则在最近版本的C标准中引入。
您可以使用 union do 来类型双关而不违反 C标准。
该程序具有未指定的行为（因为我假设
float和unsigned int具有相同的长度），但没有未定义的行为 em> （参见在这里）。One recent boost on the, already elevated, importance of the unions has been given by the Strict Aliasing Rule introduced in recent version of C standard.
You can use unions do to type-punning without violating the C standard.
This program has unspecified behavior (because I have assumed that
floatandunsigned inthave the same length) but not undefined behavior (see here).假设您有 n 种不同类型的配置（只是一组定义参数的变量）。通过使用配置类型的枚举，您可以定义一个具有配置类型 ID 的结构，以及所有不同类型配置的并集。
这样，无论您在何处传递配置，都可以使用 ID 来确定如何解释配置数据，但如果配置很大，您就不会被迫为每个潜在类型使用并行结构，从而浪费空间。
Lets say you have n different types of configurations (just being a set of variables defining parameters). By using an enumeration of the configuration types, you can define a structure that has the ID of the configuration type, along with a union of all the different types of configurations.
This way, wherever you pass the configuration can use the ID to determine how to interpret the configuration data, but if the configurations were huge you would not be forced to have parallel structures for each potential type wasting space.
联合提供了一种在单个存储区域中操作不同类型数据的方法，而无需在程序中嵌入任何与机器无关的信息
它们类似于 pascal 中的变体记录
作为一个可能在编译器符号表管理器中找到的示例，假设
常量可以是 int、float 或字符指针。特定常数的值
必须存储在适当类型的变量中，但无论其类型如何，如果该值占用相同的存储量并存储在相同的位置，则对于表管理来说是最方便的。这就是联合的目的——一个可以合法地保存多种类型中的任何一种的单个变量。语法基于结构：
变量 u 将足够大以容纳三种类型中最大的一个；具体大小取决于实现。这些类型中的任何一个都可以分配给 u，然后用于
表达式，只要用法一致
Unions provide a way to manipulate different kind of data in a single area of storage without embedding any machine independent information in the program
They are analogous to variant records in pascal
As an example such as might be found in a compiler symbol table manager, suppose that a
constant may be an int, a float, or a character pointer. The value of a particular constant
must be stored in a variable of the proper type, yet it is most convenient for table management if the value occupies the same amount of storage and is stored in the same place regardless of its type. This is the purpose of a union - a single variable that can legitimately hold any of one of several types. The syntax is based on structures:
The variable u will be large enough to hold the largest of the three types; the specific size is implementation-dependent. Any of these types may be assigned to u and then used in
expressions, so long as the usage is consistent
我想添加一个使用联合的很好的实际示例 - 实现公式计算器/解释器或在计算中使用某种形式（例如，您希望在计算的运行时期间使用可修改的部分）公式 - 数值求解方程 - 仅作为示例）。
因此，您可能想要定义不同类型（整数、浮点，甚至复数）的数字/常量，如下所示：
因此，您可以节省内存，更重要的是 - 您可以避免任何可能极端数量的动态分配（如果您使用大量运行时定义的数字）的小对象（与通过类继承/多态性的实现相比）。但更有趣的是，您仍然可以对这种类型的结构使用 C++ 多态性的强大功能（例如，如果您喜欢双重调度；）。只需将“虚拟”接口指针添加到所有数字类型的父类作为此结构的字段，指向此实例而不是/除了原始类型之外，或者使用良好的旧 C 函数指针。
因此，您可以使用多态性来代替 switch(type) 的类型检查 - 具有内存高效的实现（没有小对象的动态分配） - 当然，如果您需要的话。
I would like to add one good practical example for using union - implementing formula calculator/interpreter or using some kind of it in computation(for example, you want to use modificable during run-time parts of your computing formulas - solving equation numerically - just for example).
So you may want to define numbers/constants of different types(integer, floating-point, even complex numbers) like this:
So you're saving memory and what is more important - you avoid any dynamic allocations for probably extreme quantity(if you use a lot of run-time defined numbers) of small objects(compared to implementations through class inheritance/polymorphism). But what's more interesting, you still can use power of C++ polymorphism(if you're fan of double dispatching, for example ;) with this type of struct. Just add "dummy" interface pointer to parent class of all number types as a field of this struct, pointing to this instance instead of/in addition to raw type, or use good old C function pointers.
so you can use polymorphism instead of type checks with switch(type) - with memory-efficient implementation(no dynamic allocation of small objects) - if you need it, of course.
来自http://cplus.about.com/od/learningc/ss/lowlevel_9。嗯：
From http://cplus.about.com/od/learningc/ss/lowlevel_9.htm:
在 C 的早期（例如 1974 年记录的），所有结构为其成员共享一个公共名称空间。每个成员名称都与一个类型和一个偏移量相关联；如果“wd_woozle”是偏移量 12 处的“int”，则给定任何结构类型的指针
p，p->wd_woozle将等效于* (int*)(((char*)p)+12)。该语言要求所有结构类型的所有成员都具有唯一的名称，例外，它明确允许在使用成员名称的每个结构将它们视为公共初始序列的情况下重用成员名称。结构类型可以混杂使用这一事实使得结构的行为就好像它们包含重叠字段一样。例如，给定定义：
代码可以声明类型“float1”的结构，然后使用“成员”b0...b3 访问其中的各个字节。当更改语言以便每个结构为其成员接收单独的命名空间时，依赖于多种方式访问事物的能力的代码将会崩溃。为不同的结构类型分离命名空间的价值足以要求更改此类代码以适应它，但此类技术的价值足以证明扩展语言以继续支持它是合理的。
为利用访问
struct float1内存储的能力而编写的代码，就好像它是struct byte4一样，可以通过添加声明：union f1b4 { struct float1 ff;结构体byte4 bb； };，将对象声明为union f1b4;类型，而不是struct float1，并替换对f0、b0 的访问、b1等，以及ff.f0、bb.b0、bb.b1、虽然有更好的方法可以支持此类代码，但union方法至少在某种程度上是可行的，至少对于 C89 时代的别名规则解释来说是这样。In the earliest days of C (e.g. as documented in 1974), all structures shared a common namespace for their members. Each member name was associated with a type and an offset; if "wd_woozle" was an "int" at offset 12, then given a pointer
pof any structure type,p->wd_woozlewould be equivalent to*(int*)(((char*)p)+12). The language required that all members of all structures types have unique names except that it explicitly allowed reuse of member names in cases where every struct where they were used treated them as a common initial sequence.The fact that structure types could be used promiscuously made it possible to have structures behave as though they contained overlapping fields. For example, given definitions:
code could declare a structure of type "float1" and then use "members" b0...b3 to access the individual bytes therein. When the language was changed so that each structure would receive a separate namespace for its members, code which relied upon the ability to access things multiple ways would break. The values of separating out namespaces for different structure types was sufficient to require that such code be changed to accommodate it, but the value of such techniques was sufficient to justify extending the language to continue supporting it.
Code which had been written to exploit the ability to access the storage within a
struct float1as though it were astruct byte4could be made to work in the new language by adding a declaration:union f1b4 { struct float1 ff; struct byte4 bb; };, declaring objects as typeunion f1b4;rather thanstruct float1, and replacing accesses tof0,b0,b1, etc. withff.f0,bb.b0,bb.b1, etc. While there are better ways such code could have been supported, theunionapproach was at least somewhat workable, at least with C89-era interpretations of the aliasing rules.来自有关联合的维基百科文章：
From the Wikipedia article on unions:
union 的一个绝妙用法是内存对齐，我在 PCL（点云库）源代码中找到了它。 API 中的单一数据结构可以针对两种架构：支持 SSE 的 CPU 以及不支持 SSE 的 CPU。例如：PointXYZ 的数据结构是
3 个浮点数用一个附加浮点数填充以进行 SSE 对齐。
因此，
用户可以访问 point.data[0] 或 point.x （取决于 SSE 支持）来访问 x 坐标。
更多类似的更好的使用详细信息请参见以下链接：PCL 文档 PointT 类型
A brilliant usage of union is memory alignment, which I found in the PCL(Point Cloud Library) source code. The single data structure in the API can target two architectures: CPU with SSE support as well as the CPU without SSE support. For eg: the data structure for PointXYZ is
The 3 floats are padded with an additional float for SSE alignment.
So for
The user can either access point.data[0] or point.x (depending on the SSE support) for accessing say, the x coordinate.
More similar better usage details are on following link: PCL documentation PointT types