C++内存管理方式
C++动态内存管理兼容C语言，C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：
通过new和delete操作符进行动态内存管理。
void Test ()
{
int* p1 = (int*) malloc(sizeof(int));
free(p1);
int* p2 = (int*)calloc(4, sizeof (int));
// 这里需要free(p2)吗？
//不需要。
//1.原地扩容：二者指向同一块空间，释放一个变量即可
//2.异地扩容：在realloc阶段就会把p2释放掉，不需要手动释放，如果再次去释放就会重复释放了
int* p3 = (int*)realloc(p2, sizeof(int)*10);
//可以认为 realloc等价于 malloc + memset
free(p3);
}1.new和delete
1.1引入
int main()
{
int* p1 = (int*)malloc(sizeof(int));
//C语言需要自己计算类型的大小，还要进行强转，有些麻烦
int* p2 = new int;
//C++使用new，简化了C语言动态内存申请的方式
//C++会自动计算类型的大小，且不需要强转
//new不会初始化，C++保持一贯的思维，内置类型不做处理
//默认情况下，malloc不会初始化，所以new也选择不初始化
//二者只是用法不同，功能是相同的
return 0;
}总结：C++兼容C语言，C++内置类型的动态申请，只是在用法上简化了，功能保持一致
1.2对比
int main()
{
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
///
int* p3 = (int*)malloc(sizeof(int)*10);
int* p4 = new int[10];
free(p1);//C语言单个对象是free
free(p3);//多个对象也是free
delete p2;
delete[] p4;//C++多个对象要这样释放
//这里多个对象时，释放不加[]是否出问题，是未知的
return 0;
}1.3新语法
int main()
{
//有时开了空间，会期望初始化一下
//基于此，C++给new增加了新语法
//额外支持了 开空间+初始化
int* p5 = new int(10); //这就是初始化
int* p6 = new int[10] {1,2,3,4}; //给数组初始化
int* p7 = new int[10] {}; //这样写默认都是0
return 0;
}1.4new、delete对于自定义类型的大改进
对于内置类型来说，malloc和new区别不是很大，但是对于自定义类型，malloc很难使用，malloc只会去开空间，而不会去调用构造函数，同理free也不会去调用析构函数，new和delete的出现解决了这一问题。
1.4.1malloc如何对自定义类型对象进行初始化？
class A
{
public:
A(int a = 10)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
A* p1 = (A*)malloc(sizeof(A));
//malloc很难给自定义类型成员进行初始化
//写法一、私有成员不能访问，out
//p1->_a = 0;
//写法二、构造只能是对象创建（实例化）时自动调用函数，不能手动（显式）调用，out
//p1->A(1);
return 0;
}综上，malloc没有办法很好地支持动态申请的自定义类型对象的初始化。
1.4.2new的解决方法
class A
{
public:
A(int a = 10)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
// 自定义类型，开空间+调用构造函数初始化
A* p2 = new A; //调用默认构造
A* p3 = new A(3);
// 自定义类型，调用析构函数+释放空间
delete p2;
delete p3;
A* p4 = new A[10];
delete[] p4;
return 0;
}1.4.3对多个对象的初始化
int main()
{
A* p4 = new A[10];
delete[] p4;
//原始初始化方式
A aa1(1);
A aa2(2);
A* p5 = new A[10]{aa1, aa2};
delete[] p5;
//使用匿名对象
A* p6 = new A[10]{ A(1), A(2)};
delete[] p6;
//使用隐式类型转换
A* p7 = new A[10]{ 1, 2 };
delete[] p7;
return 0;
}1.4.4适用场景
//做OJ题时，写测试链表会更加方便
struct ListNode
{
ListNode* _next;
int _val;
ListNode(int n=10)
: _next(nullptr)
, _val(n)
{
}
};
int main()
{
ListNode* p1 = new ListNode(1);
ListNode* p2 = new ListNode(2);
ListNode* p3 = new ListNode(3);
ListNode* p4 = new ListNode(4);
ListNode* p5 = new ListNode(5);
p1->_next = p2;
p2->_next = p3;
p3->_next = p4;
p4->_next = p5;
return 0;
}1.4.5
typedef int DataType;
class Stack
{
public:
Stack(size_t capacity = 4)
{
cout << "Stack()" << endl;
_array = new DataType[capacity];//使用new改进Stack类
_capacity = capacity;
_size = 0;
}
void Push(DataType data)
{
_array[_size] = data;
_size++;
}
~Stack()
{
cout << "~Stack()" << endl;
delete[] _array;
_array = nullptr;
_size = _capacity = 0;
}
private:
DataType* _array;
int _capacity;
int _size;
};
Stack* func()
{
int n;
cin >> n;
//Stack st1(n);
//return &st1;//这样返回或是传引用返回都是不可行的
Stack* pst = new Stack(n);
return pst;
}
int main()
{
Stack* ptr = func();
ptr->Push(1);
ptr->Push(2);
// ....
cout << ptr;
delete ptr;
//不写delete不会调用析构函数，因为这是个指针，指针是内置类型
//只有自定义类型会去自动调用析构函数
//所以不写delete会发生内存泄露
return 0;
}
1.5operator new与operator delete函数
new和delete是用户进行
动态内存申请和释放的操作符，
operator new 和operator delete是系统提供的
全局函数，
new在底层调用operator new全局函数来申请空间，
delete在底层通过operator delete全局函数来释放空间。
operator new和operator delete其实是 malloc和free的封装注意：不是运算符重载！！！
operator[] 单词+符号可以不加空格，编译器也可以识别
operator new 两个关键字， 单词+ 单词，不加 空格编译器难以识别
1.5.1
//一般情况下，开辟空间是不会失败的
//除非开辟的空间非常大
//所以日常oj题目开空间不需要检查是否成功，开辟十亿byte也才将近1G
int main()
{
char* pst = new char[100000000];
cout << pst;
//char*是特殊的一个指针，其它类型指针打印都会按照指针去打印
//char*是字符串，它会按照字符串去打印，遇到\0才会截止
//所以cout不能打印char*的指针，除非去强转
cout << (void*)pst<<endl;
cout << (int*)pst <<endl;
//或者使用printf去打印
printf("%p\n", pst);
return 0;
}1.5.2抛异常
new开空间失败了，不会返回空指针，会抛异常
int main()
{
try//这里是直接捕获
{
char* p1 = new char[0x7fffffff];//有符号的最大值
//在32位下，会报错
//64位下可以考虑申请更大的空间
//new申请内存失败会抛异常，malloc会返回0
//异常会引起执行流跳跃，类似goto
cout << "hello world" << endl;
//上面开空间失败会直接跳到catch的地方
//hello world这里就不会打印
}
catch (const exception& e)//失败抛异常，就要捕获异常
{
cout << e.what() << endl;//只有出现异常，才会直接跳到catch的地方去
}
//如果不捕获异常，程序会直接终止
return 0;
}void func()
{
Stack st;
char* p1 = new char[0x7fffffff];
//char* p1 = new char[1000000000];
cout << (void*)p1 << endl;
cout << "hello world" << endl;
}
int main()
{
try//间接捕获
{
func();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}1.5.3
operator new可以显式调用，其实它就是封装的malloc
只不过malloc申请失败会返回0，而operator new会直接抛异常
所以operator new其实是给new准备的，用来给new使用的
int main()
{
Stack* pst=(Stack*)operator new(sizeof(Stack));
operator delete(pst);
return 0;
}1.5.4
int main()
{
//new可以认为是operator new和构造函数的合体
Stack* pst1 = new Stack;
delete pst1;
//free(pst1);//这样写的话没有调用析构函数，会出问题
//只是不调用析构函数不会报错，但会导致内存泄漏
return 0;
}new可以认为是operator new和构造函数的合体
delete同理
1.6. new和delete的实现原理
1.6.1内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
int main()
{
int* p1 = new int[10];
//free(p1);
delete p1;
//delete[] p1;
//因为是内置类型，这里的三个释放 效果相同
return 0;
}1.6.2自定义类型
1.6.2.1new的原理
1. 调用operator new函数申请空间2. 在申请的空间上执行构造函数，完成对象的构造
1.6.2.2delete的原理
1. 在空间上执行析构函数，完成对象中资源的清理工作2. 调用operator delete函数释放对象的空间
1.6.2.3new T[N]的原理
1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请2. 在申请的空间上执行N次构造函数
1.6.2.4delete[]的原理
1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间
1.6.3注意：匹配使用!
class A
{
public:
A()
{
_a = 10;
}
private:
int _a = 0;
};
int main()
{
A* pst = new A[10];
free(pst);
//此时虽然写的不规范，但不会报错
return 0;
}
但是如果把析构函数写出来，这里就会程序崩溃
class A
{
public:
A()
{
_a = 10;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a = 0;
};
int main()
{
A* pst = new A[10];
free(pst);
//此时写出了析构函数，这里就会程序崩溃
//delete pst; 这样写同样会崩溃
return 0;
}只有正规地匹配使用delete[]才不会报错
class A
{
public:
A()
{
_a = 10;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a = 0;
};
int main()
{
A* pst = new A[10];
//free(pst);
//delete pst; 这样写同样会崩溃
delete[] pst;
return 0;
}这是为什么呢?
class A
{
public:
A()
{
_a = 10;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a = 0;
};
int main()
{
A* pst = new A[10];
delete[] pst;
//delete (pst-1);//这样写也可以通过，验证了刚刚的底层实现过程
//但是这里析构函数次数没有调用够，如果存在资源释放问题，会发生内存泄漏
return 0;
}综上：不匹配是未定义的行为，上述处理方式换一个编译器可能都会变化，它和底层平台等各种东西都是有关系的。
1.7定位new表达式(placement-new)
1.7.1引入
C++不能显式调用构造函数，但可以显式调用析构函数。
如何解决这个问题呢？
int main()
{
A* pst=(A*)operator new(sizeof(A));
//pst->A(4); 不支持
new(pst)A(4);//显式调用
pst->~A();
operator delete(pst);
//这里就类似new和delete
return 0;
}1.7.2简介
定位new表达式是在
已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：new (place_address) type 或者 new (place_address) type(initializer-list)place_address必须是一个指针，initializer-list是类型的初始化列表
1.7.3适用场景
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
1.8malloc/free和new/delete的区别
malloc/free和 new/delete的 共同点是：都是从堆上申请空间，并且需要用户手动释放。
不同点是：
一、用法1. malloc和free是函数，new和delete是操作符2. malloc申请的空间不会初始化，new可以初始化3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可， 如果是多个对象，[]中指定对象个数即可4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常二、底层原理6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
new 主要的作用就是：1.简化用法2.解决动态申请的自定义类型对象的初始化问题
1.9内存泄漏
1.9.1概念
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
1.9.2危害
int main()
{
char* p = new char[1024 * 1024 * 1024];
//new了一个空间没有释放
//普通的内存泄漏没有什么危害
//进程结束后，会把这些资源都清理掉
return 0;
}
但长期运行的程序，出现内存泄漏，影响很大，如服务器、一些应用、操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
2.C/C++内存分布（管理）
2.1引入
内存分成这么多的区，为什么要这样设计？答案：为了对不同的内存方便管理，满足不同的需求。
2.2练习
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";
//会把值拷贝过去初始化，这里开5byte
const char* pChar3 = "abcd";
//const修饰的是指向的内容，哪怕它修饰的是本身，它也是局部变量
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);
}
扫一扫
5635
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
