为什么 new [] 搭配 delete 会崩溃？C++ 内存管理底层揭秘

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
 static int staticVar = 1;
 int localVar = 1;
 int num1[10] = { 1, 2, 3, 4 };
 char char2[] = "abcd";
 const char* pChar3 = "abcd";
 int* ptr1 = (int*)malloc(sizeof(int) * 4);
 int* ptr2 = (int*)calloc(4, sizeof(int));
 int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
 free(ptr1);
 free(ptr3);
}

   globalVar在哪里？____   
   staticGlobalVar在哪里？____
   staticVar在哪里？____   
   localVar在哪里？____
   num1 在哪里？____
   
   char2在哪里？____   
   *char2在哪里？___
   pChar3在哪里？____      
   *pChar3在哪里？____
   ptr1在哪里？____        
   *ptr1在哪里？____

   globalVar在哪里？
   globalVar是普通类型的全局变量，储存在静态区（数据段）中   
   
   staticGlobalVar在哪里？
   staticGlobalVar是static修饰的全局变量，储存在静态区（数据段）中
   
   staticVar在哪里？
   staticVar是static修饰的函数内部变量，储存在静态区（数据段）中

   localVar在哪里？
   localVar是普通的函数内部变量，储存在栈中

   num1 在哪里？
   num1是普通的函数内部的数组，储存在栈中
   
   char2在哪里？
   char2和num1一样，储存在栈中
   
   *char2在哪里？
   *char2是char2的解引用，也就是普通的函数中的数组首元素，储存在栈中
   
   pChar3在哪里？
   pChar3是普通的函数中的指针，储存在栈中
   
   *pChar3在哪里？
   *pChar3是字符串常量"abcd"的首字符，该字符串常量储存在常量区（只读数据段）中
   
   ptr1在哪里？
   ptr1是普通的函数中的指针，储存在栈中
          
   *ptr1在哪里？
   *ptr1是malloc出来的空间，属于动态申请，其内部数据储存在堆中

void Test ()
{
 int* p2 = (int*)calloc(4, sizeof (int));
 int* p3 = (int*)realloc(p2, sizeof(int)*10);

 free(p3 );
}

//new和delete是关键字，用于动态申请内存
void Test3()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;

	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);

	// 动态申请10个int类型的空间
	int* ptr6 = new int[10];

	delete ptr4;
	delete ptr5;
	delete[] ptr6;

	//申请多个对象并且初始化：
	int* ptr7 = new int[10] {0};//全部初始化为0
	int* ptr8 = new int[10] {1, 2, 3};//后面是0

	delete[] ptr7;
	delete[] ptr8;
}

struct ListNode
{
	ListNode(int x)
		:val(x)
		,next(nullptr)
	{}
	void Print(ListNode* head)
	{
		ListNode* pcur = head;
		while (pcur != nullptr)
		{
			cout << pcur->val << "->";
			pcur = pcur->next;
		}
		cout << endl;
	}
	int val;
	ListNode* next;
};

int main()
{
	ListNode* n1 = new ListNode(1);
	ListNode* n2 = new ListNode(1);
	ListNode* n3 = new ListNode(1);
	ListNode* n4 = new ListNode(1);
	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n1->Print(n1);

	return 0;
}

class A
{
public:
	A(int a1 = 0,int a2 = 0)
		: _a1(a1)
		,_a2(a2)
	{
		cout << "A():" <<_a1<<"and" << _a2 << endl;
	}
	A(const A& aa)
		: _a1(aa._a1)
		, _a2(aa._a2)
		// 显式初始化成员变量
	{
		cout << "A(const A& aa)" << endl;
	}

	~A()
	{
		cout << "~A():"<<_a1 << "and" << _a2 << endl;
	}
private:
	int _a1;
	int _a2;
};

void test4()
{
	//动态申请一个A类类型的对象
	A* p1 = new A;
	A* p2 = new A(1);

	delete p1;
	delete p2;
}


int main()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
	//还会调用构造函数和析构函数,而malloc不会
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;


	// 内置类型是几乎是一样的
	int* p3 = (int*)malloc(sizeof(int)); // C
	int* p4 = new int;
	free(p3);
	delete p4;


	A* p5 = (A*)malloc(sizeof(A) * 10);
	A* p6 = new A[10];
	free(p5);
	delete[] p6;

	//来看看和匿名对象配合使用：
	A aa1 = { 0, 0 };
	A aa2 = { 1, 1 };
	A aa3 = { 2, 2 };
	A* p7 = new A[3]{aa1,aa2,aa3};//调用构造

	//等价于：
	A* p8 = new A[3]{ A(0,0),A(1,1),A(2,2)};

	//等价于：
	A* p9 = new A[3]{ {0,0},{1,1},{2,2} };
	//三条完全等价
	return 0;
}

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
*/
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
 // try to allocate size bytes
 void *p;
 while ((p = malloc(size)) == 0)
     if (_callnewh(size) == 0)
     {
         // report no memory
         // 如果申请内存失败了，这里会抛出bad_alloc 类型异常
         static const std::bad_alloc nomem;
         _RAISE(nomem);
     }
     return (p);
}
/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void *pUserData)
{
     _CrtMemBlockHeader * pHead;
     RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
     if (pUserData == NULL)
         return;
     _mlock(_HEAP_LOCK);  /* block other threads */
     __TRY
         /* get a pointer to memory block header */
         pHead = pHdr(pUserData);
          /* verify block type */
         _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
         _free_dbg( pUserData, pHead->nBlockUse );
     __FINALLY
         _munlock(_HEAP_LOCK);  /* release other threads */
     __END_TRY_FINALLY
     return;
}
/*
free的实现
*/
#define   free(p)               _free_dbg(p, _NORMAL_BLOCK)

void func()
{
	//throw try/catch
	int n = 0;
	while (1)
	{
		void* p1 = new char[1024 * 1024 * 1024];
		cout << p1 << "->" << n << endl;
		n++;
	}
}

//但是注意，申请的是虚拟内存
//总空间：32位下：分配2^32byte->大概42亿九千万->4,294,967,296
//		  64位下：分配2^64byte->18,446,744,073,709,551,616空间
//栈空间：32位下：8M
//堆空间：32位下：1.8GB左右
int main()
{
	//申请内存失败怎么样
	try 
	{
		func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

class A
{
public:
    // 带默认参数的构造函数：初始化_a，打印对象地址
    A(int a = 0)
        : _a(a)
    {
        cout << "A():" << this << endl; // this 指向当前对象的地址
    }
    // 析构函数：打印对象地址
    ~A()
    {
        cout << "~A():" << this << endl;
    }
private:
    int _a; // 类的成员变量
};

// 定位new/replacement new
int main()
{
    // ========== 第一组：malloc + 定位new ==========
    // 1. 仅分配内存（大小=A对象大小），未调用构造函数，p1指向的不是合法对象
    A* p1 = (A*)malloc(sizeof(A));
    // 2. 定位new：在p1指向的已分配内存上，显式调用A的构造函数（无参版）
    //    此时p1才指向一个合法的A类对象
    new(p1)A; 
    // 3. 手动调用析构函数：定位new创建的对象，编译器不会自动调用析构，必须手动调用
    p1->~A();
    // 4. 释放原始内存：malloc分配的内存，用free释放
    free(p1);

    // ========== 第二组：operator new + 定位new ==========
    // 1. operator new 等价于 malloc：仅分配内存，无构造
    //    operator new 是C++内置函数，返回void*，无需强制类型转换（此处转换是为了统一写法）
    A* p2 = (A*)operator new(sizeof(A));
    // 2. 定位new：在p2指向的内存上，调用A的有参构造函数（传10）
    new(p2)A(10);
    // 3. 手动调用析构函数
    p2->~A();
    // 4. operator delete 等价于 free：释放operator new分配的内存
    operator delete(p2);

    // 上面两组操作完全等价：malloc/free ≈ operator new/operator delete
    return 0;
}

int main()
{
//内置类型：
	int* p1 = new int;
	free(p1);
	//正确：delete p1;

//自定义类型：
	A* p2 = new A;
	//free(p2);
	//这里是没有析构函数的，有内存泄露的风险
	delete p2;
	return 0;
}

class B
{
private:
	int _b1 = 1;
	int _b2 = 2;
};

class A
{
public:
	A(int a1 = 0, int a2 = 0)
		: _a1(a1)
		, _a2(a2)
	{
		cout << "A():" << _a1 << "and" << _a2 << endl;
	}
	A(const A& aa)
		: _a1(aa._a1)
		, _a2(aa._a2)
		// 显式初始化成员变量
	{
		cout << "A(const A& aa)" << endl;
	}

	~A()
	{
		cout << "~A():" << _a1 << "and" << _a2 << endl;
	}
private:
	int _a1;
	int _a2;
};


int main()
{
//内置类型：
	int* p1 = new int[10];
	delete p1;
	//不会崩溃，底层：new[] → operator new[] → 连续多次operator new → 连续多次malloc → 连续空间
	//这意味着p1这个指针只要是空间的头，就能一次delete（free）掉

//自定义类型：
	B* p2 = new B[10];
	delete p2;
	//不会崩溃
	
	A* p3 = new A[10];
	delete p3;
	//会崩溃
}