C++ union array and vars?

Question

There's no way to do something like this, in C++ is there?

union {
    {
        Scalar x, y;
    }
    Scalar v[2];
};

Where x == v[0] and y == v[1]?

Answer 1

Since you are using C++ and not C, and since they are of the same types, why not just make x a reference to v[0] and y a reference to v[1]

Answer 2

How about

union {
    struct {
        int x;
        int y;
    };
    int v[2];
};

edit:

union a {
    struct b { int first, second; } bee;
    int v[2];
};

Ugly, but that's more accurate

Answer 3

Try this:

template<class T>
struct U1
{
    U1();
    T   v[2];
    T&  x;
    T&  y;
};

template<class T>
U1<T>::U1()
    :x(v[0])
    ,y(v[1])
{}

int main()
{
    U1<int>   data;

    data.x  = 1;
    data.y  = 2;
}

Answer 4

I've used something like this before. I'm not sure its 100% OK by the standard, but it seems to be OK with any compilers I've needed to use it on.

struct Vec2
{
  float x;
  float y;
  float& operator[](int i) { return *(&x+i); }
};

You can add bounds checking etc to operator[] if you want ( you probably should want) and you can provide a const version of operator[] too.

If you're concerned about padding (and don't want to add the appropriate platform specific bits to force the struct to be unpadded) then you can use:

struct Vec2
{
  float x;
  float y;
  float& operator[](int i) {
    assert(i>=0);
    assert(i<2);
    return (i==0)?x:y;
  }
  const float& operator[](int i) const {
    assert(i>=0);
    assert(i<2);
    return (i==0)?x:y;
  }
};

Answer 5

I was looking for a similair thing and eventually came up with a solution.

I was looking to have a data storage object that I could use as both an array of values and as individual values (for end-user flexibility in writing Arduino libraries).

Here is what I came up with:

class data{
    float _array[3];

    public:
    float& X = _array[0];
    float& Y = _array[1];
    float& Z = _array[2];

    float& operator[](int index){
        if (index >= 3) return _array[0]; //Make this action whatever you want...
        return _array[index];
    }
    float* operator&(){return _array;}
};


int main(){
    data Test_Vector;
    Test_Vector[0] = 1.23; Test_Vector[1] = 2.34; Test_Vector[2] = 3.45;

    cout<<"Member X = "<<Test_Vector.X;
    cout<<"Member Y = "<<Test_Vector.Y;
    cout<<"Member Z = "<<Test_Vector.Z;

    float* vector_array = &Test_Vector;

    cout<<"Array = {"<<vector_array[0]<<", "<<vector_array[1]<<", "<<vector_array[2]<<"}";
}

Thanks to Operator overloading, we can use the data object as if was an array and we can use it for pass-by-reference in function calls (just like an array)!

If someone with More C++ experience has a better way of applying this end product, I would love to see it!

EDIT: Changed up the code to be more cross-platform friendly

Answer 6

Given your example:

union
{
    struct
    {
        Scalar x, y;
    };

    Scalar v[2];
};

As others have noted, in general, the standard does not guarantee that there will be no padding between x and y, and actually compilers inserting padding in structures is pretty common behavior.

On the other hand, with solutions like:

struct U
{
    int   v[2];
    int&  x;
    int&  y;
};

U::U()
    : x(v[0])
    , y(v[1])
{}

what I don't like mainly is the fact that I have to mention x, y twice. For cases where I have more than just a few elements (say 10), this becomes much less readable and harder to maintain - e.g. if you want to change the order of x,y then you have to change the indexes below too (well not mandatory but otherwise order in memory wouldn't match order of fields, which would not be recommended). Also, U can no longer be a POD since it needs a user-defined constructor. And finally, the x & y references consume additional memory.

Hence, the (acceptable for me) compromise I've come up with is:

struct Point
{
    enum CoordType
    {
        X,
        Y,
        COUNT
    };

    int coords[CoordType::COUNT];
};

typedef Point::CoordType PtCoord;

With this you can then do:

Point p;
for ( int i = 0; i < PtCoord::COUNT; i++ )
    p.coords[i] = 100;
std::cout << p.coords[PtCoord::X] << " " << p.coords[PtCoord::Y] << std::endl;

// 100 100

A bit sophisticated but I prefer this over the references suggestion.

Answer 7

With C++11 you have anonymous unions and structs which just export their definitions to the enclosing scope, so you can do this:

typedef int Scalar;
struct Vector
{
    union
    {
        struct
        {
            Scalar x, y;
        };
        Scalar v[2];
    };
};

Answer 8

Depending on what "Scalar" is, yes, you can do that in C++. The syntax is almost exactly (maybe even exactly exactly, but I'm rusty on unions) what you wrote in your example. It's the same as C, except there are restrictions on the types that can be in the unions (IIRC they must have a default constructor). Here's the relevant Wikipedia article.