Array of class holding an array memory layout

user_14914614 0
Viewed 73

If we have a class which holds an array, let's call it vector and hold the values in a simple array called data:

class vector
{
public:
   double data[3];
   <...etc..>
};

Note: called as vector is for clearer explanation, it is not std::vector!!!

So my question is that, if I store only typedefs near this array inside the class and some constrexpr, am I correct if the class will be only 3 doubles after each other inside the memory? And then if i create an array of vectors like:

vector vl[3];

Note: size of the array is not always known at compile time, not use 3 for the example.

then in the memory it'll be just 9 doubles after each other, right? so vl[0].data[3] will always return the 2nd vectors 1st element? And in this case is it guaranteed that the result will be always like a simple array in the memory?

I found only cases with array of arrays, but not with array of classes holding an array, and I'm not sure if it is exactly the same at the end. I made some tests and it seems like it is working as I expected, but I don't know if it is always true.. Thank you!

class arrays c++
2 Answers

Mostly, yes.

The standard doesn't promise that there never is anything after data in the representation of a vector, but all the implementations that I know of won't add any padding in this case.

What is promised is that there is no padding before data in the representation of vector, because it is a StandardLayout type.

user_26108100

You are right with your first example: The class layout is like a C struct. The first member resides at the address of the struct itself, and if it is an array, all the array's members are adjacent.

Between struct members, however, may be padding; so there is no guarantee that the size of a struct is the sum of all member sizes. I'd have to dig into the standard but I assume this includes padding at the end. This answer affirms that; assert(sizeof(vector) == 3*sizeof(double)) may not hold. In reality I'd assume that an implementation may pad a struct containing three chars so that the struct aligns at word boundaries in an array, but not three doubles which are typically the type with the strongest alignment requirements. But there is no guarantee between implementations, architectures and compiler options: Imagine we switch to 128 bit CPUs.

With respect to your second example: The above applies recursively, so the standard gives no guarantee that the 9 doubles will be adjacent. On the other hand, I bet they will be, and the program can assert it with a simple compile-time static_assert.

user_31508020
Related