How is an array aligned in C++ compared to a type contained?

Question

Suppose I have some type T that has to be N bytes aligned. Now I declare an array of type T:

T array[size];

Will the array have the same alignment requirements as type T or will it have any other alignment requirements?

Answer 1

Yes, the alignment requirements must be the same. Obviously an array of T must be aligned at least as strictly as a single T otherwise its first member would not be properly aligned. The fact that an array cannot be more strictly aligned than its element type follows from the standard section 8.3.4 which says that arrays are contiguously allocated element subobjects. Consider this array of arrays:

T a[2][size];

Whatever the value of size, there can be no "extra" padding between the two arrays a[0] and a[1] otherwise this violates the contiguosly allocated requirement.

Equivalently, we know that (char*)&a[1] == (char*)&a[0] + sizeof(a[0]) and sizeof(a[0]) == sizeof(T[size]) == size * sizeof(T). As this holds for any size it must be possible to place an array of T at any address which is suitably aligned for a single T object (given adequate address space).

Answer 2

The array's alignment requirements will be identical to those of the array elements, I believe.

Obviously, the start of the array must be aligned at least as strictly as its first element requires, so its alignment requirements can't be less strict.

The start address of the array plus the size of each element must leave the second element sufficiently aligned. That places a constraint on the size of the element type, which I believe means padding can be introduced at the end of a structure just to keep arrays aligned, even if you never use that struct in an array. But it does not mean there's any need for stricter alignment.

By induction, subsequent elements are OK if the first two are OK, so giving the array the same alignment requirements as its elements should be fine.

A citation from the spec would be nice, though.

Answer 3

The rules are the same i believe but the interpretation might be confusing.

I believed since each element of array would be of the same size so only aligning the first element would automatically align the rest and hence there would never be any padding between elements.

This might be true in case of a trivial array but not for complex scenarios.

The stride of an array can be large than element size i.e. there could be pads between each individual elements.

Following is a good example

struct ThreeBytesWide {
    char a[3];
};

struct ThreeBytesWide myArray[100];

source - stride wikipedia

Each element of ThreeBytesWide array could be aligned to four byte boundary

Edit: As elaborated in the comments, the mention of having pads between individual elements is when the element itself is say 3 bytes and aligned to four byte boundary.

Answer 4

An array of objects is required to be contiguous, so there's never padding between the objects, though padding can be added to the end of an object (producing nearly the same effect). C++ Data Member Alignment and Array Packing

#include <iostream>

__declspec(align(32)) 
struct Str1
{
   int a;
   char c;
}; 

template<typename T>
struct size
{
    T arr[10];
};


int main()
{
    size<Str1> b1;

    std::cout << sizeof(Str1) << std::endl; //  prints 32
    std::cout << sizeof(b1) << std::endl;   //  prints 320

    std::cin.ignore();
    return 0;
}

References:

1. Data alignment in C++, standard and portability
2. http://msdn.microsoft.com/en-us/library/83ythb65.aspx