在联盟中命名数组元素或结构和数组

Question

Consider the following struct:

struct Vector4D
{
   union
   {
      double components[4];
      struct { double x, y, z, t; } Endpoint;
   };
};

It seems to me that I have seen something similar in WinApi's IPAddress struct. The idea is to give me the possibility to use the array components both by index and by name, for example:

Vector4D v;
v.components[2] = 3.0;
ASSERT(v.Endpoint.z == 3.0) //let's ignore precision issues for now

In the C++ standard there is a guarantee that there will be no "empty" space at the beginning of a POD-struct, that is, the element x will be situated right in the beginnig of the Endpoint struct. Good so far. But I don't seem to find any guarantees that there will be no empty space or padding, if you will, between x and y , or y and z , etc. I haven't checked out the C99 standard though.

The problem is that if there is an empty space between Endpoint struct elements, then the idea will not work.

Questions:

1. Am I right that there indeed is no guarantee that this will work either in C or C++.

2. Will this practically work on any known implementation? In other words, do you know of any implementation where this doesn't work?

3. Is there any standard(I mean not compiler-specific) way to express the same idea? Maybe the C++0x alignment features might help?

By the way, this isn't something I am doing in production code, don't worry, just curious. Thanks in advance.

Answer 1

1. yes
2. depends on the alignment needs of the architecture and the compilers strategy
3. no, but you could make a object wrapper (but you will end up with .z() instead of just .z )

Most compilers should support squashing a structure using a pragma or an attribute. #pragma pack for example.

Answer 2

You can circumvent any memory alignment issues by having references to each element of the array, as long as you declare the array before the references in the class to ensure they point to valid data. Having said that I doubt alignment would be an issue with doubles, but could be for other types (float on 64bit arch perhaps?)

#include <iostream>
using namespace std;

struct Vector4D
{
    Vector4D() : components(), x(components[0]), y(components[1]), z(components[2]), t(components[3]) { }

    double components[4];

    double& x;
    double& y;
    double& z;
    double& t;
};

int main()
{
    Vector4D v;

    v.components[0] = 3.0;
    v.components[1] = 1.0;
    v.components[2] = 4.0;
    v.components[3] = 15.0;

    cout << v.x << endl;
    cout << v.y << endl;
    cout << v.z << endl;
    cout << v.t << endl;
}

Hope this helps.

Answer 3

When it comes to the standard, there are two problems with it:

• It is unspecified what happens when writing to an element in a union and reading from another, see the C standard 6.2.6.1 and K.1
• The standard does not guarantee the layout of the struct match that of the layout of the array, see the C standard 6.7.2.1.10 for details.

Having said this, in practice this will work on normal compilers. In fact, this kind of code is widely spread and is often used to reinterpret values of one type into values of another type.

Answer 4

Padding bytes will not cause an issue as all variables are of type double . The compiler will treat Vector4D as a double array. That means, v.Endpoint.z is essentially the same as v[2] .