массив символов как хранилище для размещения новых

Да, это проблематично. У вас просто нет гарантии, что память правильно выровнена.

Хотя существуют различные уловки для получения хранилища с правильным выравниванием, лучше всего использовать Boost или C ++ 0x aligned_storage, которые скрывают эти уловки от вас.

Тогда вам просто необходимо:

// C++0x
typedef std::aligned_storage<sizeof(my_class),
                                alignof(my_class)>::type storage_type;

// Boost
typedef boost::aligned_storage<sizeof(my_class),
                        boost::alignment_of<my_class>::value>::type storage_type;

storage_type storage; // properly aligned
new (&storage) my_class(); // okay

Обратите внимание, что в C ++ 0x, используя атрибуты, вы можете просто сделать это:

char storage [[align(my_class)]] [sizeof(my_class)];

Как уже упоминалось здесь, это не обязательно сработает из-за ограничений выравнивания. Есть несколько способов добиться правильного выравнивания. Во-первых, если у вас есть компилятор, совместимый с C ++ 0x, вы можете использовать оператор alignof, чтобы попытаться заставить выравнивание быть правильным. Во-вторых, вы можете динамически выделять массив символов, поскольку память от оператора new гарантированно будет выровнена таким образом, чтобы что угодно могло ее правильно использовать. В-третьих, вы можете попробовать сохранить массив символов в объединении с некоторым типом, который имеет максимально возможное выравнивание в вашей системе; Я считаю, что эта статья содержит некоторую информацию по этому поводу (хотя она разработана для C ++ 03 и, конечно, не так же хорошо, как и оператор alignof, который скоро выйдет).

Надеюсь это поможет!

Это как минимум проблематично из-за выравнивания.

В большинстве архитектур, отличных от Intel, код будет генерировать «ошибку шины» из-за неправильного выравнивания или будет работать очень медленно из-за ловушек процессора, необходимых для исправления невыровненного доступа к памяти.

На архитектуре Intel это обычно будет немного медленнее, чем обычно. За исключением случаев, когда задействованы некоторые операции SSE, это также может привести к сбою.

Если кто-то хочет избежать Boost или C ++ 1x, этот полный код работает как в GCC, так и в MSVC. Специфичный для MSVC код основан на align_memory.h. Это немного сложнее, чем версия GCC, потому что __declspec(align(.)) MSVC принимает только литеральные значения выравнивания, и это обходится с использованием специализации шаблона для всех возможных выравниваний.

#ifdef _MSC_VER

template <size_t Size, size_t Align>
struct AlignedMemory;

#define DECLARE_ONE_ALIGNED_MEMORY(alignment) \
template <size_t Size> \
struct __declspec(align(alignment)) AlignedMemory<Size, alignment> { \
    char mem[Size]; \
};

DECLARE_ONE_ALIGNED_MEMORY(1)
DECLARE_ONE_ALIGNED_MEMORY(2)
DECLARE_ONE_ALIGNED_MEMORY(4)
DECLARE_ONE_ALIGNED_MEMORY(8)
DECLARE_ONE_ALIGNED_MEMORY(16)
DECLARE_ONE_ALIGNED_MEMORY(32)
DECLARE_ONE_ALIGNED_MEMORY(64)
DECLARE_ONE_ALIGNED_MEMORY(128)
DECLARE_ONE_ALIGNED_MEMORY(256)
DECLARE_ONE_ALIGNED_MEMORY(512)
DECLARE_ONE_ALIGNED_MEMORY(1024)
DECLARE_ONE_ALIGNED_MEMORY(2048)
DECLARE_ONE_ALIGNED_MEMORY(4096)

#else

template <size_t Size, size_t Align>
struct AlignedMemory {
    char mem[Size];
} __attribute__((aligned(Align)));

#endif

template <class T>
struct AlignedMemoryFor : public AlignedMemory<sizeof(T), __alignof(T)> {};

Массив char может быть неправильно выровнен для размера myclass. На некоторых архитектурах это означает более медленный доступ, а на других - сбой. Вместо char вы должны использовать тип, выравнивание которого равно или больше, чем у struct, которое задается наибольшим требованием выравнивания любого из его членов.

#include <stdint.h>

class my_class { int x; };

int main() {
    uint32_t storage[size];
    new(storage) my_class();
}

Чтобы выделить достаточно памяти для одного my_class экземпляра, я думаю, что size должно быть sizeof(my_class) / sizeof(T), где T - это тот тип, который вы используете для правильного выравнивания.