Is it possible to skip bytes when using union, in c++?

Question

I'm attempting to use a union for a couple of structs, specfically aligning a 2D (4 by 4) float array with 4 Vector4's.

From my understanding, union looks at the sequential bytes from the first. If I have a 4x4 array and want to get a whole column, I would need to skip 16 bytes to get to the next row.

Example:

Matrix = {{a, b, c, d},
          {e, f, g, h},
          {h, i, j, k},
          {l, m, n, o};

if the data is given such that a 1D array is {a,b,c,d,e,..., o}, how would I get the last column (d,h,k,o)?

So how would I get the bytes: 12->16, 28->32, 44->48, 60->64?

the code I have that returns the last row (not what I want), is:

//matrix.h
struct Matrix4 {
    union{
        float values[4][4];
        Vector4 column[4];
    };

    //matrix methods etc
}

//main.cpp
Matrix4 position = Matrix3::translation(Vector3(1,2,3));
Vector4 column = position.column[2];
std::cout << (column) << std::endl;

The output matrix would be (don't remember how to use LaTex formatting sorry):

| 1 0 0 1 |
| 0 1 0 2 |
| 0 0 1 3 |
| 0 0 0 1 |

So the column I want is:

|1|
|2|
|3|
|1|

and the union gives:

|0|
|0|
|0|
|1|

(the last row, not column).

Would it just be easier to refactor my code to use a 1D array to get the sequential bytes or should I change how my matricies are constructed? or can I handle this with some other thing in union?

EDIT: My question is different to this other question because I already have created a matrix class and allocated memory. My question looks at the functionality of "union" and its limits, as well as using my definied struct 'Vector4' as a means of representing some data in a matrix. I'm looking into the possibility of skipping bytes to receive data that doesn't directly follow each other, not how to allocate said bytes.

Answer 1

This is a fairly common pattern, but an invalid one. It's popular because it's easy, and because mainstream compilers have traditionally permitted and supported it.

But you simply cannot, in a well-defined way, make use of unions in this manner. Unions are not a way to reinterpret data of one type as data of another type. Heck, reinterpret_cast doesn't even get you there: to do it safely you'd have to keep std::copying your bytes back and forth. The only time it's safe is with a char[] (or unsigned char[], or std::byte[]) which is allowed to alias arbitrary blocks of memory: as a consequence, unions can be useful for quick byte inspection. Beyond that, they are useful only if you don't need to use more than one of the union's members at a time.

What you should really be doing is picking one layout/format, then adding your own operator[] (or other function) variants on top to provide different interfaces and ways of interpreting the data at your call site.

Do it right and there'll not be any overhead.

Do it cleverly and you'll be able to apply your transformation "on the fly" in just the way you need. Provide a proxy type, a kind of iterator, that doesn't just iterate in linear sequence but instead iterates in the modified sequence that you need.

This logic can all be encapsulated in your Matrix4 type.

Answer 2

You cannot access two different members of a union at the same time. The example from cppreference:

#include <string>
#include <vector>

union S
{
    std::string str;
    std::vector<int> vec;
    ~S() {} // needs to know which member is active, only possible in union-like class 
};          // the whole union occupies max(sizeof(string), sizeof(vector<int>))

int main()
{
    S s = {"Hello, world"};
    // at this point, reading from s.vec is undefined behavior
[...]

ie after assigning the str member you are not allowed to access the vec member.

Answer 3

So hereby I decide to add a brand new answer involving none undefined behaviour I believe. Starring force type conversion:

#include <cstdlib>
#include <iostream>
#include <initializer_list>

using namespace std;

// Matrix4f dimension
#define DIM_MAT4        (4)

// Data structures
typedef struct _Vector4f
{
    float entries[DIM_MAT4];

    void
    println() const;

} Vector4f;

typedef struct _Matrix4f
{
    _Matrix4f(initializer_list<float> fl) : _trans_cache(NULL), _renew_cache(true)
    {
        copy(fl.begin(), fl.end(), entries);
    }

    _Matrix4f() : entries{.0f, .0f, .0f, .0f,
                    .0f, .0f, .0f, .0f,
                    .0f, .0f, .0f, .0f,
                    .0f, .0f, .0f, .0f}, _trans_cache(NULL), _renew_cache(true) {}

    ~_Matrix4f() { delete _trans_cache; }

    float &
    operator() (int, int);

    const float &
    operator() (int, int) const;

    const Vector4f *
    getRow(int) const;

    const Vector4f *
    getCol(int) const;

    _Matrix4f *
    transpose() const;

    void
    println() const;

private:

    float entries[DIM_MAT4 * DIM_MAT4];

    // cache the pointer to the transposed matrix
    mutable _Matrix4f *
    _trans_cache;
    mutable bool
    _renew_cache;

} Matrix4f;

Matrix4f *
Matrix4f::transpose() const
{
    if (not _renew_cache)
        return this->_trans_cache;

    Matrix4f * result = new Matrix4f;

    for (int k = 0; k < DIM_MAT4 * DIM_MAT4; k++)
    {
        int j = k % DIM_MAT4;
        int i = k / DIM_MAT4;

        result->entries[k] = this->entries[i + DIM_MAT4 * j];
    }

    _renew_cache = false;
    return this->_trans_cache = result;
}

float &
Matrix4f::operator() (int rid, int cid)
{
    _renew_cache = true;
    return this->entries[rid * DIM_MAT4 + cid];
}

const float &
Matrix4f::operator() (int rid, int cid) const
{
    return this->entries[rid * DIM_MAT4 + cid];
}

const Vector4f *
Matrix4f::getRow(int rid) const
{
    return reinterpret_cast<Vector4f *>(&(this->entries[rid * DIM_MAT4]));
}

const Vector4f *
Matrix4f::getCol(int cid) const
{
    return this->transpose()->getRow(cid);
}

void
Matrix4f::println() const
{
    this->getRow(0)->println();
    this->getRow(1)->println();
    this->getRow(2)->println();
    this->getRow(3)->println();

    cout << "Transposed: " << this->_trans_cache << endl;
}

void
Vector4f::println() const
{
    cout << '(' << (this->entries[0]) << ','
            << (this->entries[1]) << ','
            << (this->entries[2]) << ','
            << (this->entries[3]) << ')' << endl;
}

// Unit test
int main()
{
    Matrix4f mat = {1.0f, 0.0f, 0.0f, 1.0f,
                    0.0f, 1.0f, 0.0f, 2.0f,
                    0.0f, 0.0f, 1.0f, 3.0f,
                    0.0f, 0.0f, 0.0f, 1.0f};

    mat.println();

    // The column of the current matrix
    // is the row of the transposed matrix
    Vector4f * col = mat.getCol(3);

    cout << "Vector:" << endl;

    col->println();

    cout << "Matrix(2,3) = " << mat(2, 3) << endl;

    return 0;
}

Answer 4

Unions are only used to reserve a region of memory to different objects. But at each instant there can be only one alive object. So as a general rule if you have a union with two members a and b, if you have initialized a and a is the active member of the union, you should never try to read the value of b.

But there is an exception to this rule in the case where a and b share a common initial sequence: in this case the standard ensures the memory representation of a and b are sufficiently similar so that you can access the value of a through b.

Below an example of code that show defined behavior of access to union value through an inactive member:

    struct Vector4 {
       float values[4];
       };
    //I propose you two kinds of matrix, as is usualy done in linear algebra
    //left_matrix are efficient for matrix multiplication if they are on the
    //left side of the * symbol.
    struct left_matrix{
       Vector4 rows[4];
       //for this simple example we index using call operator:
       float& operator()(int i,int j){
           return rows[i].values[j];
           }
       };

    struct right_matrix{
       Vector4 columns[4];
       float& operator()(int i, int j){
          return columns[j].values[i];//the actual memory transposition is here.
          }
        };

    right_matrix 
    transpose_left_matrix(const left_matrix& m){
        union{
          left_matrix lm;
          right_matrix rm;
          };
        lm = m; //lm is the active member
        return rm; //but we can access rm
        }

Answer 5

The following answer is intended for G++ compiler and it is more efficient if you want to access columns of the same matrix repeatly.

#include <iostream>

using namespace std;

typedef struct _Vector4f
{
    float entries[4];
} Vector4f;

typedef struct _Matrix4f
{
    union {
        float entries[16];
        Vector4f rows[4];
    };

    // cache the pointer to the transposed matrix
    struct _Matrix4f *
    _trans_cache;

    struct _Matrix4f *
    transpose();

} Matrix4f;

Matrix4f *
Matrix4f::transpose()
{
    if (this->_trans_cache)
        return this->_trans_cache;

    Matrix4f * result = new Matrix4f;

    for (int k = 0; k < 16; k++)
    {
        int j = k % 4;
        int i = k / 4;

        result->entries[k] = this->entries[i + 4 * j];
    }

    return this->_trans_cache = result;
}

int main()
{
    Matrix4f mat = {1.0f, 0.0f, 0.0f, 1.0f,
                    0.0f, 1.0f, 0.0f, 2.0f,
                    0.0f, 0.0f, 1.0f, 3.0f,
                    0.0f, 0.0f, 0.0f, 1.0f};
    Vector4f col = mat.transpose()->rows[3];

    cout << (col.entries[0]) << ','
            << (col.entries[1]) << ','
            << (col.entries[2]) << ','
            << (col.entries[3]) << end;

    return 0;
}

At last, I want OP know that there are many libraries out there which implements many complex matrix operations, such as GNU Scientific Library. So there is hardly any reason to invent a wheel again. Hehe. :P