C / C++ / MFC

new ((void *) (&pBlock[i * sizeof(CDataSlice)])) CDataSlice();

void * pv=(void *)&pBlock[i * sizeof(CDataSlice)];
CDataSlice * ps=new (pv) CDataSlice();

#include "windows.h"
#include <iostream.h>
#include <stdio.h>
  
  
class foo {
public:
    foo(){}
    ~foo(){
        cout << "destroying " << i << endl;
    }
  
    foo(int n) : i(n){
        cout << "constructing " << i << endl;
    };
  
    void* operator new (size_t sz, void* p) {
       return p;
    }
     
<code>//  static void  operator delete(void *p, size_t sz) {}; // only problem left... </code>
     
private:
    int i, j, k, l;     // 4 X 4 ?
};
   
   
int main(int argc, char* argv[])
{
   
    HANDLE hHeap = GetProcessHeap();
  
    if(hHeap) {
 
        // alloc space from heap 
        void * vp = HeapAlloc(hHeap, HEAP_ZERO_MEMORY, 20 * sizeof(foo));   // space for 20 foos
        foo * fooPs[20];
 
        // create 20 foos
        for (int i = 0; i < 20; ++i) {
            fooPs[i] = new ((foo*)vp+i)foo(i); // foo* cast is important - a void object has no size
        }
 
        // destroy 20 foos
        for ( i = 0; i < 20; ++i ) {
            fooPs[i]->foo::~foo();
        }
 
        // free mem
        HeapFree(hHeap, 0, vp);
    }
  
    int x;
    cin >> x;
  
    return 0;
}

class V {
public:
  V() {}
  ~V() {}
  virtual void wank() = 0;
};

class B {
public:
  B() {}
  ~B() {}
  void wank() {}
};

class D1 : public V {
  int i,j,k,l;
public:
  D1() {}
  ~D1() {}
  void wank() {}
};

class D2 : public B {
  int i,j,k,l;
public:
  D2() {}
  ~D2() {}
  void wank() {}
};

ASSERT(sizeof(D1) == 20);
ASSERT(sizeof(D2) == 16);