typedef bcn::vector_builder<Obj> obj_vector_builder;
typedef bcn::fast_vector<Obj> obj_vector;

obj_vector method()
{
    obj_vector_builder b;
    b.insert(10,Obj(...));
    b.push_back(Obj());
    ...

    return b.yield();
}

struct v
{
    char a;
    int  b;
    char c;
    int  d;
    char e;
    int  f;
    char g;
    int  h;
};

MS>struct v
MS>{
MS>    char a;
MS>    int  b;
MS>    char c;
MS>    int  d;
MS>    char e;
MS>    int  f;
MS>    char g;
MS>    int  h;
MS>};
MS>

Nonstatic data members of a (non-union) class declared without an intervening access-specifier are allocated so that later members have higher addresses within a class object. The order of allocation of nonstatic data members separated by an access-specifier is unspecified (11.1). Implementation alignment requirements might cause two adjacent members not to be allocated immediately after each other; so might requirements for space for managing virtual functions (10.3) and virtual base classes (10.1).

>> struct v
>> {
>>     char a;
>>     int  b;
>>     char c;
>>     int  d;
>>     char e;
>>     int  f;
>>     char g;
>>     int  h;
>> };
>>

char a[5] = {0}; 
int i = *(int*)(a + 1);

    //This union is used to ensure that COW storage elements will be 
properly aligned.
    template<class AllocatorT> union cow_storage_element
    {
        typedef boost::detail::atomic_count counter_type;
        typedef typename AllocatorT::value_type value_type;

        typename boost::type_with_alignment<
            (boost::alignment_of<counter_type>::value > 
boost::alignment_of<value_type>::value)
            ? boost::alignment_of<counter_type>::value
            : boost::alignment_of<value_type>::value
            >::type a;
        char counter_[sizeof(counter_type)];
        char data_[sizeof(value_type)];
    };

cow_storage_element *data=allocate(...);
new(&(data->counter_[0])) boost::detail::atomic_count(1);
...
new(&(data[1].data_[0])) value_type(...);

#ifdef _WIN32
//Non-aligned types can be safely used on win32.
template<class T> size_t alignment_of()
{
    return 1;
}
#else
//General fallback implementation.
template<class T> size_t alignment_of()
{
    return sizeof(T);
}
#endif

...

char a[5+(alignment_of(int)+1)/2]; //This array will have enough space 
for properly aligned int.
int i=*(int*)(a+a%alignment_of(int)); //Get properly aligned integer.

union
{
    char a[5];
    int i;
};

> надо писать примерно так (опять код из моей библиотеки ):

int main()
{
     size_t const align = 0x1000;
     size_t const buf_size = 8;

     char buf[buf_size + align - 1];
     char* aligned_buf = buf + align - 1 - (((uint_ptr_t)buf + align - 1) % align);

     printf("%x %x\n", buf, aligned_buf);
}

mov eax,[esi]