15.6.1 Array Allocation [hier.array]

The operator new() and operator delete() functions allow a user to take over allocation and
deallocation of individual objects; operator new[]() and operator delete[]() serve exactly the
same role for the allocation and deallocation of arrays. For example:

class Employee {
public :
    void* operator new[](size_ t);
    void operator delete[](void*, size_ t);
    // ...
};

void f(int s)
{
    Employee* p = new Employee[s];
    // ...
    delete[] p ;
}

Here, the memory needed will be obtained by a call,

    Employee::operator new[](sizeof(Employee) * s + delta)

where delta is some minimal implementation-defined overhead, and released by a call:

    Employee::operator delete[](p, s * sizeof(Employee) + delta)

The number of elements (s) is ‘‘remembered’’ by the system.

(Bjarne Stroustrup, The C++ Programming Language, Third Edition)

5.3.5 Delete [expr.delete]

1 The delete-expression operator destroys a most derived object (1.8) or array created by a new-expression.
delete-expression:
::opt delete cast-expression
::opt delete [ ] cast-expression
The first alternative is for non-array objects, and the second is for arrays. The operand shall have a pointer
type, or a class type having a single conversion function (12.3.2) to a pointer type. The result has type
void.

2 If the operand has a class type, the operand is converted to a pointer type by calling the above-mentioned
conversion function, and the converted operand is used in place of the original operand for the remainder of
this section. In either alternative, if the value of the operand of delete is the null pointer the operation
has no effect. In the first alternative (delete object), the value of the operand of delete shall be a pointer
to a non-array object or a pointer to a sub-object (1.8) representing a base class of such an object (clause
10). If not, the behavior is undefined. In the second alternative (delete array), the value of the operand of
delete shall be the pointer value which resulted from a previous array new-expression. If not, the
behavior is undefined.

typedef
  int
  some_type[10];

some_type * h= new some_type; /* вроде это преобразуется в: new int[10] */
delete h;

S>typedef
S>  int
S>  some_type[10];
S>some_type * h= new some_type; /* вроде это преобразуется в: new int[10] */
S>delete h;
S>

struct some_type {
  int arr[10];
  int& operator[](int i){return *(arr + i);}
}

int arr[10];
int[] elt = arr + 3; //Ok
int[] elt = &arr[3]; //Ok
elt++; //ok
int*  obj = arr + 3; //err
int*  obj = static_cast<int*>(arr + 3); //Ok
int* obj = &arr[3]; //err
int* obj = static_cast<int*>(&arr[3]);
obj++ //err

T>>Этот момент как-то обошли в данном обсуждении.

struct Test1 {
    Test1() { printf("Test1\r\n"); }
    virtual ~Test1() { printf("~Test1\r\n"); }

    virtual void CallMe() = 0;
};

struct Test2 : public Test1 {
    int t;

    void CallMe() {};

    Test2() { printf("Test2\r\n"); }
    virtual ~Test2() { printf("~Test2\r\n"); }
};

Test1* AllocateArray() {
    return new Test2[2];
}

void DeleteArray(Test1* arr) {
    arr[0].CallMe();
    arr[1].CallMe(); //vfpt безнадежно испорчен :(
    delete[] arr;
}

void main() {
    DeleteArray(AllocateArray());
}

S>>typedef
S>>  int
S>>  some_type[10];
S>>some_type * h= new some_type; /* вроде это преобразуется в: new int[10] */
S>>delete h;
S>>

T>struct some_type {
T>  int arr[10];
T>  int& operator[](int i){return *(arr + i);}
T>}
T>

T>int arr[10];
T>int[] elt = arr + 3; //Ok
T>int[] elt = &arr[3]; //Ok
T>elt++; //ok
T>int*  obj = arr + 3; //err
T>int*  obj = static_cast<int*>(arr + 3); //Ok
T>int* obj = &arr[3]; //err
T>int* obj = static_cast<int*>(&arr[3]);
T>obj++ //err
T>

#include <stdio.h>
#include <new.h>

struct TEST {
  TEST() {
    printf(__FUNCSIG__ "\n");
  }
  ~TEST() {
    printf(__FUNCSIG__ "\n");
  }
};

template<class T> class DtorClassWrapper {
  T Wrappee;
  template<class AS> friend void DestructMeAs(void* pObj);
};

template<class AS> void ConstructMeAs(void* pObj) {
  ::new (pObj) AS;
}
template<class AS> void DestructMeAs(void* pObj) {
  //reinterpret_cast<AS*>(pObj)->AS::~AS(); //Оппа, не сработало :(
  //::delete(pObj,pObj); //И подавно, зачем тогда размещающий delete нужен? :(

  //Дубовая заплатка :)
  typedef DtorClassWrapper<AS> DTOR_TYPE;
  reinterpret_cast<DTOR_TYPE*>(pObj)->DTOR_TYPE::~DTOR_TYPE();
};

int main() {
  typedef TEST ARR[2];
  //T_ALIGNED_STORAGE<ARR,2,1> buf;
  char buf[sizeof(ARR)]; //Чхали на выравнивание..
  ConstructMeAs<ARR>(buf);
  //blabla..
  DestructMeAs<ARR>(buf);
}

Ovl>стало интересно, пытался сделать тест, получилось

Ovl>struct Test1 {
Ovl>    Test1() { printf("Test1\r\n"); }
Ovl>    virtual ~Test1() { printf("~Test1\r\n"); }

Ovl>    virtual void CallMe() = 0;
Ovl>};

Ovl>struct Test2 : public Test1 {
Ovl>    int t;

Ovl>    void CallMe() {};

Ovl>    Test2() { printf("Test2\r\n"); }
Ovl>    virtual ~Test2() { printf("~Test2\r\n"); }
Ovl>};

Ovl>Test1* AllocateArray() {
Ovl>    return new Test2[2];
Ovl>}

Ovl>void DeleteArray(Test1* arr) {
Ovl>    arr[0].CallMe();
Ovl>    arr[1].CallMe(); //vfpt безнадежно испорчен :(
Ovl>    delete[] arr;
Ovl>}

Ovl>void main() {
Ovl>    DeleteArray(AllocateArray());
Ovl>}
Ovl>

class VOID_TYPE {};
typedef struct VTableTag* VTable;

template<class T> const VTable* GetVTablePointer() {
  static T dummy = VOID_TYPE(); //Avoiding manual-forced vfptr initializing
  return reinterpret_cast<VTable*>(*reinterpret_cast<unsigned int*>(&dummy));
}
template<class T> void SetVTablePointer(T* pObj) {
  *reinterpret_cast<const VTable**>(pObj) = GetVTablePointer<T>();
}

struct Test1 {
  Test1() { SetVTablePointer(this); } //Not needed for test, just in case
  Test1(VOID_TYPE) { } //Void constructor
  virtual ~Test1() { printf(__FUNCSIG__ "\n"); }
  virtual void CallMe() { printf(__FUNCSIG__ "\n"); }
};

struct Test2 : public Test1 {
  Test2() { SetVTablePointer(this); } //Manual-forced vfptr initializing
  Test2(VOID_TYPE) : Test1(VOID_TYPE()) { } //Void constructor
  virtual ~Test2() { printf(__FUNCSIG__ "\n"); }
  void CallMe() { printf(__FUNCSIG__ "\n"); }; //Cheking virtual function
};

Test1* AllocateArray() {
  return new Test2[2];
}

void DeleteArray(Test1* arr) {
  arr[0].CallMe();
  arr[1].CallMe(); //Works..
  delete[] arr; //Cleaning..
}

int main() {
  DeleteArray(AllocateArray());
  return 0;
}

void __thiscall Test2::CallMe(void)
void __thiscall Test2::CallMe(void)
__thiscall Test2::~Test2(void)
__thiscall Test1::~Test1(void)
__thiscall Test2::~Test2(void)
__thiscall Test1::~Test1(void)

void __thiscall Test2::CallMe(void)
void __thiscall Test2::CallMe(void)
__thiscall Test2::~Test2(void)
__thiscall Test1::~Test1(void)
__thiscall Test2::~Test2(void)
__thiscall Test1::~Test1(void)
__thiscall Test2::~Test2(void)
__thiscall Test1::~Test1(void)
__thiscall Test1::~Test1(void)

void Test2::CallMe()
void Test2::CallMe()
Test1::~Test1()
Test1::~Test1()
Test2::~Test2()
Test1::~Test1()
Test1::~Test1()

    y=new A[1];
    x=new A();
    y=new A[1];
    x=new A();
    y=new A[1];
    x=new A();
    x=new A();
    x=new A();
    x=new A();
    y=new A[1];
    y=new A[1];
    y=new A[1];
    y=new A[1];

template <class T >struct autoVelo
{ T* privatPtr;
  inline autoVelo(T*p){privatPtr=p;}
  inline operator T*(){return privatPtr;} 
  inline ~autoVelo()
   { if(privatPtr)
     if(0xF&(unsigned)(void*)privatPtr)
       delete[] privatPtr;
     else
        delete privatPtr;     
   }
  private:
  operator =( autoVelo<T>){}
};


..............
    autoVelo<A> a0(new A [1] );
    autoVelo<A> a1(new A (9,9) );