Перегрузка operator new

    Array::Array(const size_t size):_size(size)
    {
        printf("Array::Array(const size_t size)\n");
        if (_size>0 && _size<UINT_MAX){
            if ( (_data = new int[_size]) == 0)
                printf("error no memory");
        }
    }
    Array::Array( Array const * const src):_size(src->_size)
    {
        printf("Array::Array( Array const * const src)\n");
 
        if ( (_data = new int[_size]) == 0)
            printf("error no memory");
        for (int i=0; i<_size;i++)
            _data[i] = src->_data[i];
    }
 
    Array::~Array(){
        printf("Array::~Array()\n");
        delete[] _data;
    }

class Scoped_ptr_arr{
 
private:
    Array * _ptr;
 
    // zapret for BUG fix!!!! call to copy of object or operator=
    Scoped_ptr_arr(const Scoped_ptr_arr & pArray){printf("Scoped constr from class!\n");};
    Scoped_ptr_arr & operator= (const Scoped_ptr_arr&) {};
 
public:
    Scoped_ptr_arr(Array * pArray): _ptr(pArray){printf("Scoped constr from &Array!\n");};
 
    ~Scoped_ptr_arr(){if (_ptr) delete _ptr; printf("Scoped destruct Array!\n");}
 
    Array * ptr(){return  _ptr;}    // return addres then can obj.ptr()->doSomthing();
    bool isNull(){ return _ptr == 0;}
 
    Array * operator-> () {return _ptr;}
    Array & operator*  () {return *_ptr;}
};

    Array arr(10); // i^2
 
    for (int i = 0; i<10;i++)
        arr.set(i,i*i);
 
    {
        Scoped_ptr_arr pArray = new Array(arr);
 
    }   // automat destruct on end of scope not need delete after new
 
    int t;
    scanf("%d",&t);
 
return 0;
}

if ( (_data = new int[_size]) == 0)

_ptr(pArray)

    
void* Array::operator new (size_t size) throw (bad_alloc) {
        printf("Array::operator new(%ld)\n",size  );
        Array* bar = (Array*)::operator new(size);
//      bar->Array(??);
        return bar;
    }

        Scoped_ptr_arr pArray = new Array(1);

        Scoped_ptr_arr pArray = new Array(arr);

#include <iostream>
 
struct A
{
   A() {}
   A(A* ptr)
   {
      std::cout << "from pointer c-tor called" << std::endl;
   }
};
 
struct C
{
   C(A* ptr) : ptr_(ptr)
   {
   }
private:
   A* ptr_;
};
 
int main()
{
   C c = new A();
}

#include <iostream>
 
struct A
{
   A() {}
   A(A* ptr)
   {
      std::cout << "from pointer c-tor called" << std::endl;
   }
};
 
struct C
{
   C(A* ptr) : ptr_(ptr)
   {
   }
private:
   A ptr_;
};
 
int main()
{
   C c = new A();
}

_ptr(new Array(ptr))