cpp
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";//char2指针在栈上，在栈上开一个空间存放abcd，指针就指向这个空间。
const char* pChar3 = "abcd";//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);
}1内存简介
栈又叫堆栈 局部变量（非静态）、函数参数、返回值等等，栈是向下增长的。
堆用于程序运行时动态分配内存，堆可以向上增长。
数据段全局数据和静态数据。
代码段 可执行代码和只读常量。
C语言的动态内存管理方式malloc calloc realloc
cpp
class A
{
public:
A(int a1 = 0, int a2 = 0)
:_a1(a1)
,_a2(a2)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a1(aa._a1)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a1 = aa._a1;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a1 = 1;
int _a2 = 1;
};
int main()
{
int* ptr1 = new int(0);
delete ptr1;
int* ptr2 = new int[10] {1, 2, 3};
delete[] ptr2;
int* ptr3 = new int{ 0 };
delete ptr3;
//A* ptr4 = new A;
//delete ptr4;
//A aa1(1);
//A* ptr5 = new A(aa1);
//delete ptr5;
//A* ptr6 = new A(1);
//delete ptr6;
//A* ptr7 = new A{ 1,4 };
//delete ptr7;
//A* ptr8 = new A[3]{ A(1,2),A(4,5)};
//delete[] ptr8;
return 0;
}
cpp
//struct ListNode
//{
// int val;
// ListNode* next;
//
// ListNode(int x)
// :val(x)
// , next(nullptr)
// {
// }
//};
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;
return 0;
}C++的动态内存管理方式new和 delete操作符进行动态内存管理。
cpp
int main()
{
//throw try/catch
try
{
void* p1 = new char[1024 * 1024 * 1024];
cout << p1 << endl;
void* p2 = new char[1024 * 1024 * 1024];
cout << p2 << endl;
void* p3 = new char[1024 * 1024 * 1024];
cout << p3 << endl;
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}2operator new和 operator dalete
1operator new
通过调用malloc来申请空间，malloc申请空间成功了以后，直接返回
申请失败以后，执行空间失败的应对措施，如果应对措施用户设置了，则继续申请。否则抛异常。
2operator delete
最终也是通过free来释放内存的。
3new和delete的实现原理
1 内置类型
如果申请的是内置类型的空间 new delete和malloc free 基本相似。
new 申请失败会抛异常，malloc会返回null
new delete申请和删除的是单个元素的空间，而new[] delete[]申请和删除的是一段连续的空间。
2自定义类型
1new的原理
1调用operator new函数申请空间
2在申请的空间上执行构造函数，完成对象的构造。
2delete的原理
1在空间上执行析构函数，完成对象中资源的清理。
2调用operator delete函数释放对象空间
3new[T]的原理
1调用operator new[ ] 函数 实际调用调用operator new完成对N个对象空间的申请
2在申请的空间上执行N次构造函数，完成对象的构造。
4delete[T]的原理
1在释放的空间上执行N次析构函数，完成N个对象中资源的清理。
2调用operator delete[ ]释放空间，实际在operator delete[ ]中调用operator delete来释放空间
cpp
int main()
{
int* p1 = new int;
//free(p1);
delete p1;
return 0;
}
class B
{
private:
int _b1 = 2;
int _b2 = 2;
};
int main()
{
B* p2 = new B[10];
//free(p2);
A* p3 = new A[10];
delete[] p2;
delete[] p3;
//free(p3);
return 0;
}4malloc free 和 new delete的区别
共同点
：都是在堆上申请空间，都需要自己手动释放空间。
区别
1.前两个是函数，后两个是操作符
2malloc申请的空间不会初始化，new申请的空间会初始化
3malloc申请空间需要手动计算大小并传递，new只需后面跟上申请的类型。多个对象在[申请对象的个数]
4malloc申请空间的返回值是void* ，使用时必须强转，new不需要，new后面跟的就是空间类型。
5malloc申请失败，返回的是null，所以使用时必须判空。new不需要，但是new需要捕获异常。
6申请自定义类型时，malloc和free只会申请和释放空间。
new会申请资源后调用构造函数完成对象的初始化。
delete会在释放空间之前调用析构函数完成空间中资源的清理。