C++基础入门（动态内存管理）

1、C语言中的动态内存管理：

在C语言中用malloc和realloc还有colloc，来进行动态内存管理

1、malloc：开辟一个新的空间，不对空间进行初始化和任何操作；

2、realloc:  更改动态分配的内存大小。

注意：如果想扩容的空间还没有开辟空间，那么realloc的用法就等价于malloc。如果将内存块移动到新位置(异地扩容),之前内存块的内容也会随之转移到新的位置.但新的部分是未被初始化的.

 如果我们使用malloc开辟并初始化5个整型,然后使用realloc扩容到10个整型后  打印：

 3、calloc：calloc与malloc之间的不同点是，malloc 不会设置内存为零，而 calloc 会设置分配的内存为零。

 int *pn = (int*)calloc(10, sizeof(int));//开辟十个整形，并且全部初始化为0；
 int *pn = (int*)calloc(1, sizeof(int)*10);//开辟一个十个整形的空间，并且初始化为0；

 2、C++动态内存管理

C++兼容C，所以C语言中的动态内存管理在C++中可以继续使用，但是C++中新加了自己的动态内存管理模式，在C语言中动态内存管理是函数，在C++中动态内存管理是操作符，对应的C++的动态内存管理是new和delete。

C++中开辟一个空间和开辟十个空间：

#include<iostream>
using namespace std;
int main()
{
	//开辟一个int类型的空间
	int* p1 = new int;
	//开辟十个int类型的空间
	int* p2 = new int[10];
    delete[] p2;//释放
	delete p1;
	return 0;
}

C语言中的malloc不支持初始化，但是C++中new支持初始化。在内置类型中，C++的new的优势不大。

C++中的初始化：

#include<iostream>
using namespace std;
int main()
{
	//开辟一个int类型的空间，并初始化为1；
	int* p1 = new int(1);
    //开辟十个int类型的空间，并初始化。
	int* p2 = new int[10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	delete[] p2;//释放
	delete p1;
	return 0;
}

但是在自定义类型中，new就体现出它的优势了

例如：对于自定义类型，如果在C++中成员变量是私有的，我们就不能像C语言那样直接用成员变量初始化了，但是如果我们用new的话，new就会自动调用构造函数进行初始化。

class A
{
public:
	A(int a = 0)
		:_a1(a)
		,_a2(nullptr)
	{}
private:
		int _a1;
        int* _a2;
};

int main()
{
	A* p1 = new A(1);//隐式类型转换
	A* p2 = new A[10]{ 1,2,3,4 };
	delete[] p2;
	delete p1;
}

如果是多参数的默认构造函数的初始化只需要在内部加上花括号，将多个参数包含在内即可

class A
{
public:
	A(int a = 0, int b = 0)
		:_a1(a)
		,_a2(nullptr)
	{}
private:
	int _a1;
    int* _a2;

};

int main()
{
	A* p3 = new A[10]{ {1,2},{2,3},1,2,3 };
	delete[] p3;
    return 0;
}

operator new和operator delete

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

/*
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)

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果
malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施
就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

new 和 delete的底层：

new的底层是operator new+构造函数，operator new的底层其实是malloc+抛出异常
delete的底层是operator delete+析构函数，operator delete的底层其实是free

operator new和operator delete的底层是malloc和free进行封装的结果。

定位new表达式（placement-new）

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

用法:

1、new(指向对象的指针）对象类型；

2、new(指向对象的指针）对象类型（初始化列表）；
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如
果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

#include<iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << endl;
	}
	~A()
	{
		cout << "~A():" << endl;
	}
private:
	int _a;
};

// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));//malooc开辟出来的类没有初始化
	new(p1)A;   // 注意：如果A类的构造函数有参数时，此处需要传参
	
	p1->~A();
	free(p1);

	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}