How force alignment of heap-allocated objects?

Question

In How use alignof to force alignment for a heap allocation?, I asked how to use alignof for heap-allocated objects. Now I'm generalizing my question for any way to force alignment of heap-allocated objects, because I can't find a way to do it using alignof, std::aligned_storage, or std::align. The following code compiles, but neither VC12 nor Clang 3.2 produce the sequence of zeros as output that would indicate that my alignment request is being respected. (gcc 4.8.1 lacks std::align, but if you comment that part out, the code compiles under gcc 4.8.1 and also produces output indicating that my alignment requests are being ignored.)

#include <iostream>
#include <memory>

int main()
{
  // Try using alignas on the allocation
  {
    class Widget {};

    for (int i = 0; i < 5; ++i)
      {
        auto ptr = new alignas(64) Widget;
        std::cout << (long)ptr % 64 << '\n';    // should be 0
      }
  }

  // Try using alignas on the type
  {
    class alignas(64) Widget {};

    for (int i = 0; i < 5; ++i)
      {
        auto ptr = new Widget;
        std::cout << (long)ptr % 64 << '\n';    // should be 0
      }
  }

  // Try using std::aligned_storage
  {
    class Widget {};

    using WidgetStorage_t = 
      std::aligned_storage<sizeof(Widget), 64>::type;

    for (int i = 0; i < 5; ++i)
      {
        auto ptr = new WidgetStorage_t;         // get buffer
        new (ptr) Widget;                       // construct Widget
        std::cout << (long)ptr % 64 << '\n';    // should be 0
      }
  }

  // Try using operator new + std::align
  {
    class Widget {};

    for (int i = 0; i < 5; ++i)
      {
        auto requestSize =      // double space to ensure that a
          2 * sizeof(Widget);   // Widget fits after ptr adjustment

        auto ptr = operator new(requestSize);   // get buffer

        std::align(64, sizeof(Widget),          // align ptr 
                   ptr, requestSize);           // inside buffer

        new (ptr) Widget;                       // construct Widget

        std::cout << (long)ptr % 64 << '\n';    // should be 0
      }
  }
}

UPDATE: My code for testing std::align is incorrect above. The following replacement code works:

 // Try using operator new + std::align
  {
    class Widget {};

    for (int i = 0; i < 5; ++i)
      {
        auto requestSize =       // ensure that a
          sizeof(Widget) + 64;   // Widget fits after ptr adjustment

        auto ptr = operator new(requestSize);   // get buffer

        std::align(64, sizeof(Widget),          // align ptr 
                   ptr, requestSize);           // inside buffer

        new (ptr) Widget;                       // construct Widget

        std::cout << (long)ptr % 64 << '\n';    // should be 0
      }
  }

Is this the only way to get the job done? It's a lot more complicated than I'd like, because now two pointers have to be tracked: the adjusted one that points to the object (necessary to destroy the constructed object) and the unadjusted one that points to the memory buffer (necessary for releasing the memory).

Answer 1

One option I've seen used in practice is to over-allocate, then align things for yourself.

For example, let's say you want to allocate N bytes aligned to M byte boundaries. You can proceed by allocate N+M-1 bytes, then find the first M-byte aligned address in the allocated space. For example, you can do something like:

const size_t N = sizeof(Widget);
const size_t M = 64;
char *pc = new char[N+M-1];
char *pc_aligned = (pc+M-1)&(~(M-1));
Widget *p = new (pc_aligned) Widget();    // placement new
// ...
p->~Widget();                             // explicitly call destructor
delete [] pc;                             // delete array allocated with new

Answer 2

MS clearly document that C++11 alignas is unimplemented at http://msdn.microsoft.com/en-us/library/hh567368.aspx

For GNU - seems it works if you put it in the right place - from Where can I use alignas() in C++11? just a taste - see that answer for many more examples and discussion:

typedef float aligned_block alignas(16) [4];
typedef float aligned_block [4] alignas(16);