1

A std::vector<char> contains a pointer to some heap-allocated buffer.

Considering memory alignment issues, is the allocated buffer returned by the memory allocation guaranteed to be correctly aligned for only the type char, or will it be aligned to some common value, such as 4 or 8 bytes? (Or is it unspecified?)

To explain by way of example, the default allocator is new. Calling new may return an arbitrary memory address. But is it really arbitrary?

  • Perhaps it is 8-byte aligned on 64 bit machines?
  • Perhaps it is aligned for the type T used in std::vector<T>? (This seems the most likely of the options.)
  • Perhaps the returned address is arbitrary, and can have any value. (I don't think this is correct.)
  • Something else?

The reason for asking this question is that I want to know whether I can safely re-interpret the bytes contained within this block of memory as other types, for example float, double, uint64_t, etc.

Going the other way, the situation is more obvious. (I think - do correct me.)

For example, if we were to ask for a std::vector<uint64_t>, then the pointer returned by the memory allocation, and held by the std::vector object, would be 8-byte aligned.

So it would be safe to read and write data as:

  • char*
  • Correctly aligned (4-byte aligned) float
  • Correctly aligned (8-byte) double
  • Correctly aligned (2-byte) unsigned short int
  • ... etc

However, if the allocation for std::vector<char> can return a memory address of 1025 (decimal), then this is clearly not guaranteed to be aligned correctly at any offset if re-interpreted as any type larger than 1 byte wide.

I think my understanding is correct here, but of course do let me know in the comments if any of this doesn't quite make sense or fit together correctly.

Edit:

I may have found an answer to this, but I am not sure how to interpret what I have read.

From:

This function is required to return a pointer suitably aligned to point to an object of the requested size.

But what does this mean?

For an object of width 1 byte, this would seemingly suggest any address value is acceptable.

For an object of width 2 bytes, it would suggest any even value address is acceptable.

For 4 bytes, any multiple of 4. And for 8 bytes any multiple of 8.

But what about other values? There is no instruction to load a 3 byte value from memory in x86, as far as I am aware. What happens if you request new[T] where T is a 3 byte wide struct?

Improve this question
3
  • The default_allocator is built on new [], therefore this answers your question: Does new char actually guarantee aligned memory for a class type? Commented Feb 8 at 13:58
  • @Homer512 That question only answers for a single type T, not for re-interpreting a pointer to T as a pointer to some other type U Commented Feb 8 at 13:59
  • No, please read the first answer. It specifically says that new char[] is sufficiently aligned for any object. It's literally the first line. All you need to know in addition is that the default allocator uses new char[] under the hood. And that's what I just told you Commented Feb 8 at 16:50

1 Answer 1

Reset to default
2

While it technically doesn't seem to be guaranteed, I'm fairly sure no implementation is going to give you an under-aligned pointer from a std::vector<char>.

The default operator new returns a memory aligned to __STDCPP_DEFAULT_NEW_ALIGNMENT__, and while I can't find any guarnatees that this is >= alignof(std::max_align_t), any sane implementation would do it this way.

There's also a version of operator new that takes std::align_val_t, and while its intent is to support larger alignments, there's no guarantee that std::allocator doesn't call it for smaller alignments too, though a sane implementation probably either wouldn't do it, or if it would, the call would still ensure at least __STDCPP_DEFAULT_NEW_ALIGNMENT__ alignment.

A big part of why I expect this to work in practice is that std::align_val_t and the overaligned operator new were added relatively recently, in C++17. Before that you had to have __STDCPP_DEFAULT_NEW_ALIGNMENT__ >= alignof(std::max_align_t) for new to work sanely, and std::vector<char> had to give you a pointer aligned at least to __STDCPP_DEFAULT_NEW_ALIGNMENT__, so I doubt the implementations are going to suddenly drop this guarantee.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

I'm not sure I understand this precisely. Does this mean that operator new always returns an 8-byte aligned memory address on a 64 bit system? I'm not sure how to interpret "no implementation is going to give you an under-aligned pointer". Does "under-aligned" mean not a multiple of 8?
@user2138149 operator new returns memory aligned to __STDCPP_DEFAULT_NEW_ALIGNMENT__ (that's 16 on all platforms I just tested) if you don't specify alignment yourself. I think that even if you specify alignment, it will refuse to align to less than that amount, but it's not guaranteed anywhere as far as I can tell. In this case by "underaligned" I mean "aligned less than __STDCPP_DEFAULT_NEW_ALIGNMENT__", but I'm using the word loosely, the proper definition is probably "aligned less than alignof(std::max_align_t)".
That's interesting. Any idea why 16 bytes?
@user2138149 Not sure. Some SSE stuff apparently requires 16 byte alignment, but I haven't used it.
That would make sense. But there's SSE 512 as well, which is 64 bytes. (And 256 of course.)

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.