class c
{
   int n_;
   int* ptr_;
public:
   c(int n) n_(n) { ptr_ = new int[n_]; }
   ~c() { delete [ptr_]; }
   //copy ctor, operator =()...
};

B>class c
B>{
B>   int n_;
B>   int* ptr_;
B>public:
B>   c(int n) n_(n) { ptr_ = new int[n_]; }
B>   ~c() { delete [ptr_]; }
B>   //copy ctor, operator =()...
B>};
B>

class c
{
    int n_;
    int size_;
    char offset_;
    
    c(int n, int sz) : n_(n), size_(sz)
    {
        memset(&offset_, 0, size_);
    }
    
public:
    c* allocate(int n, int sz)
    {
        c* ptr = reinterpret_cast<c*>(malloc(size_of(c) + sz - 1));
        new(ptr)c(n, sz);
    }
}

B>>Не нравится мне что-то такая идея. А как быть с конструктором копирования и оператором присваивания?

c* pc1 = c::allocate(1, 20);
c* pc2 = c::allocate(1, 40);

*pc1 = *pc2;

maq>аллокатор тут не поможет

class my_allock
{
   friend class holder;
   char* ptr_;
   my_allock();
   my_allock(const my_allock&);
   my_allock& operator = (const my_allock&);
   static char* allocate();
   static void deallocate(char* ptr);
}; 

class holder
{
   int n_;
   static int size_;
   char* ptr_;
public:
   static void set_size(int size) { size_ = size; }
   holder(int n) : n_(n) { ptr_ = my_allock::allocate(); }
   
   holder(const holder& rhs) : n_(rhs.n_)
   {
      ptr_ = my_allock::allocate();
   }

   holder& operator = (const holder& rhs)
   {
      if(this != &rhs)
      {
         n_ = rhs.n_;
         memcpy(ptr_, rhs.ptr_, size_);
      }
   }

   ~holder() { my_allock::deallocate(ptr_); }
};