el mejor método multiplataforma para obtener memoria alineada

Mientras estés de acuerdo con tener que llamar a una función especial para hacer la liberación, tu enfoque está bien. Sin embargo, haría sus #ifdefal revés: comience con las opciones especificadas por los estándares y vuelva a las opciones específicas de la plataforma. Por ejemplo

1. Si __STDC_VERSION__ >= 201112L utilizar aligned_alloc.
2. Si _POSIX_VERSION >= 200112L utilizar posix_memalign.
3. Si _MSC_VER está definido, utilice el material de Windows.
4. ...
5. Si todo lo demás falla, simplemente use malloc/free y desactivar SSE / AVX codificar.

El problema es más difícil si desea poder pasar el puntero asignado a free; eso es válido en todas las interfaces estándar, pero no en Windows y no necesariamente con la función heredada memalign que tienen algunos sistemas unix.

Aquí está una muestra fija de user2093113, el código directo no se compiló para mí (void* tamaño desconocido). También lo puse en una clase de plantilla overriding operator new/delete para que no tenga que hacer la asignación y la colocación de llamadas new.

#include <memory>

template<std::size_t Alignment>
class Aligned
{
public:
    void* operator new(std::size_t size)
    {
        std::size_t space = size + (Alignment - 1);
        void *ptr = malloc(space + sizeof(void*));
        void *original_ptr = ptr;

        char *ptr_bytes = static_cast<char*>(ptr);
        ptr_bytes += sizeof(void*);
        ptr = static_cast<void*>(ptr_bytes);

        ptr = std::align(Alignment, size, ptr, space);

        ptr_bytes = static_cast<char*>(ptr);
        ptr_bytes -= sizeof(void*);
        std::memcpy(ptr_bytes, &original_ptr, sizeof(void*));

        return ptr;
    }

    void operator delete(void* ptr)
    {
        char *ptr_bytes = static_cast<char*>(ptr);
        ptr_bytes -= sizeof(void*);

        void *original_ptr;
        std::memcpy(&original_ptr, ptr_bytes, sizeof(void*));

        std::free(original_ptr);
    }
};

Úsalo así:

class Camera : public Aligned<16>
{
};

Aún no probamos la multiplataforma de este código.

Si el compilador lo soporta, C++11 agrega una función std::align para hacer la alineación del puntero en tiempo de ejecución. Puedes implementar tu propio malloc / free así (no probado):

template<std::size_t Align>
void *aligned_malloc(std::size_t size)
{
    std::size_t space = size + (Align - 1);
    void *ptr = malloc(space + sizeof(void*));
    void *original_ptr = ptr;

    char *ptr_bytes = static_cast<char*>(ptr);
    ptr_bytes += sizeof(void*);
    ptr = static_cast<void*>(ptr_bytes);

    ptr = std::align(Align, size, ptr, space);

    ptr_bytes = static_cast<void*>(ptr);
    ptr_bytes -= sizeof(void*);
    std::memcpy(ptr_bytes, original_ptr, sizeof(void*));

    return ptr;
}

void aligned_free(void* ptr)
{
    void *ptr_bytes = static_cast<void*>(ptr);
    ptr_bytes -= sizeof(void*);

    void *original_ptr;
    std::memcpy(&original_ptr, ptr_bytes, sizeof(void*));

    std::free(original_ptr);
}

Entonces no tiene que mantener el valor del puntero original para liberarlo. Si esto es 100% portátil No estoy seguro, pero espero que alguien me corrija si no!

Aquí están mis 2 centavos:

temp = new unsigned char*[num];
AlignedBuffers = new unsigned char*[num];
for (int i = 0; i<num; i++)
{
    temp[i] = new  unsigned char[bufferSize +15];
    AlignedBuffers[i] = reinterpret_cast<unsigned char*>((reinterpret_cast<size_t>
                        (temp[i% num]) + 15) & ~15);// 16 bit alignment in preperation for SSE
}