C / C++ / MFC

///Elements requiring explicit initialization
/// \note Elements don't have a default Ctor.
class Element
{
public:
    /// init an element
    Element(ParamType _a)
    { ... }
private:
    //your implementation
};

static const size_t BUFSZ = ...;

/// a class aggragating \c BUFSZ elements
class Aggregate
{
public:
    /// initialize with _a
    Aggregate(ParamType _a) :vector()
    { 
        vector = reinterpret_cast<Element*>(buffer);
        for(size_t i=0; i<BUFSZ; ++i)
            new(vector+i)Element(_a); //< USE PLACEMENT NEW
    }
    /// do proper element copy (not just bulk memory copy)
    Aggregate(const Aggregate& _s)
    {
        vector = reinterpret_cast<Element*>(buffer);
        for(size_t i=0; i<BUFSZ; ++i)
            new(vector+i)Element(_s.vector[i]); //< USE PLACEMENT NEW to construct copies
    }
    /// do proper element destruction
    ~Aggregate()
    {
        for(size_t i=0; i<BUFSZ; ++i)
            vector[i].~Element(); //< DO EXPLICIT DESTRUCTION
    }
private:
    char buffer[BUFSZ*sizeof(Element)];
    Element* vector;    
};

2 bugs found.
> recompile ...
65534 bugs found.

class YourClass
{
    public:
        YourClass() : mys( 2, MyClass( 7 ) )
        {}

        std::vector<MyClass> mys;
};

class B
{
	public:
		B( int ) {}
};

class A
{
	public:
		A() : values_( reinterpret_cast<B (&)[2]>( raw_buff_[ 0 ] ) )
		{
		}

	private:
		char raw_buff_[ sizeof( B[2] ) ];
		B (&values_)[2];
};

A() : values_( reinterpret_cast<B (&)[2]>( raw_buff_[ 0 ] ) )
{
	std::uninitialized_fill( &values_[ 0 ], &values_[ 2 ], B( 7 ) );
}

template <class T1, class T2> void construct(T1* p, const T2& value)
{
	new( p ) T1( value );
}

A() : values_( reinterpret_cast<B (&)[2]>( raw_buff_[ 0 ] ) )
{
	construct( &values_[ 0 ], B( 1 ) );
	construct( &values_[ 1 ], B( 2 ) );
}

template <class T> void destroy(T* p)
{
    p->~T();
}

~A()
{
    destory( &values_[ 0 ] );
    destroy( &values_[ 1 ] );
}