CODEWITHSUNDEEP
c++c++11memory-alignmentalignof
BeeOnRope
BeeOnRope

Reputation: 64925

Is it always the case that sizeof(T) >= alignof(T) for all object types T?

For any object type T is it always the case that sizeof(T) is at least as large as alignof(T)?

Intuitively it seems so, since even when you adjust the alignment of objects like:

struct small {
  char c;
};

above what it would normally be, their "size" is also adjusted upwards so that the relationship between objects in an array makes sense while maintaining alignment (at least in my testing). For example:

struct alignas(16) small16 {
  char c;
};

Has both a size and alignment of 16.

Upvotes: 51

Views: 4518

Answers (4)

user2357112
user2357112

Reputation: 280638

At least in standard C++, for anything you can make an array of (with length > 1), this will have to be true. If you have

Foo arr[2];

and alignof(Foo) > sizeof(Foo), then arr[0] and arr[1] can't both be aligned.

As Zalman Stern's example shows, though, at least some compilers will allow you to declare a type with alignment greater than its size, with the result that the compiler simply won't let you declare an array of that type. This is not standards-compliant C++ (it uses type attributes, which are a GCC extension), but it means that you can have alignof(T) > sizeof(T) in practice.

The array argument assumes sizeof(Foo) > 0, which is true for any type supported by the standard, but o11c shows an example where compiler extensions break that guarantee: some compilers allow 0-length arrays, with 0 sizeof and positive alignof.

Upvotes: 38

o11c
o11c

Reputation: 16056

Many compilers allow arrays of size 0. The alignment remains the same as the alignment of the sole element.

(Among other things, this is useful for forcing a particular alignment in cases when you can't use a bitfield)

Upvotes: 7

Daniel Trugman
Daniel Trugman

Reputation: 8501

According to the c++ 11 standard that introduced the alignof operator, sizeof is defined as following (see 5.3.3 expr.sizeof):

The sizeof operator yields the number of bytes in the object representation of its operand

Whereas alignof definition is (see 5.3.6 expr.alignof):

An alignof expression yields the alignment requirement of its operand type.

Since the defintion of alignof specifies a requirement, possibly made by the user, rather than a specification of the language, we can manipulate the compiler:

typedef uint32_t __attribute__ ((aligned (64))) aligned_uint32_t;
std::cout << sizeof(aligned_uint32_t) << " -> " << alignof(aligned_uint32_t);
// Output: 4 -> 64

Edited

As others have pointed out, such types cannot be used in arrays, e.g trying to compile the following:

aligned_uint32_t arr[2];

Results in error: alignment of array elements is greater than element size

Since arrays require the specified type to conform with the condition: sizeof(T) >= alignof(T)

Upvotes: 10

Zalman Stern
Zalman Stern

Reputation: 3191

#include <iostream>

typedef double foo __attribute__ ((aligned (64)));
alignas(64) double bar;
double baz __attribute__ ((aligned (64)));

int main(int argc, char *argv[]) {
    std::cout << "foo sizeof: " << sizeof(foo) << " alignof: " << alignof(foo) << "\n";
    std::cout << "bar sizeof: " << sizeof(bar) << " alignof: " << alignof(decltype(bar)) << "\n";
    std::cout << "baz sizeof: " << sizeof(baz) << " alignof: " << alignof(decltype(baz)) << "\n";
}

Compile with:

clang++ -std=c++11 alignof_test.cpp -o alignof_test && ./alignof_test

Output:

foo sizeof: 8 alignof: 64
bar sizeof: 8 alignof: 8
baz sizeof: 8 alignof: 8

So strictly speaking, no, but the above argument re: arrays has to be preserved.

Upvotes: 17

Related Questions