Problems caused by delete and delete[]

One 、 problem 1：delete A pointer to a array new The pointer to , Cause the program to exit abnormally

	Foo* p1 = new Foo[2];
	delete p1;

1、arary new The memory structure of the dynamic application is roughly shown in the figure below （vs2022）

2、 By looking at the memory layout .

3、 stay operator delete Breaking point , It is found that the pointer passed in points to the address of the first object , stay free Function causes a crash .

Compare call delete [] p1, The incoming pointer phead Is a pointing record array size Size address .

Two 、 problem 2：array delete A pointer to a new The pointer to , This causes the destructor to keep calling

Foo* p2 = new Foo;
delete [] p2;

1、new The memory structure of the dynamic application is roughly shown in the figure below （vs2022）

2、 By looking at the memory layout .

3、 stay Foo Destructor break point for , Disassembly , Find the... That controls the call destructor count It's a random value , This causes the destructor to be called continuously

3、 ... and 、 Test code

// -------- xxx.hpp
#pragma once

#include <iostream>
#include <memory>

class Foo {
    
public:
	Foo()  {
     std::cout << " Foo : " << this << std::endl; }
	~Foo() {
     std::cout << "~Foo : " << this << std::endl; }

	static void* operator new(size_t size);
	static void operator delete(void* phead, size_t size);
	static void* operator new[](size_t size);
	static void operator delete[](void* pheda, size_t size);

private:
	char _char1 = 170;      // 0xAA
	int _int1 = 2864434397; // 0XAABBCCDD
};

// operator new
void* Foo::operator new(size_t size)
{
    
	void* ret = ::operator new(size);;
	std::cout << "new, pointer : " << ret << ", size : " << size << std::endl;
	return ret;
}

// operator delete
void Foo::operator delete(void* phead, size_t size)
{
    
	std::cout << "delete, pointer : " << phead << ", size : " << size << std::endl;
	free(phead);
}

// operator new[]
void* Foo::operator new[](size_t size)
{
    
	void* ret = ::operator new[](size);
	std::cout << "new [], pointer : " << ret << ", size : " << size << std::endl;
	return ret;
}

// operator delete[]
void Foo::operator delete[](void* phead, size_t size)
{
    
	std::cout << "delete [], pointer : " << phead << ", size : " << size << std::endl;
	free(phead);

void test()
{
    
	Foo* p1 = new Foo[2];
	delete  p1;       //  Abnormal exit 
	//delete [] p1; 

	Foo* p2 = new Foo;
	delete[] p2;    //  Call the destructor countless times 
	//delete p2;
}