经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » C++ » 查看文章
【重学C++】01| C++ 如何进行内存资源管理?
来源:cnblogs  作者:会玩code  时间:2023/5/22 8:51:21  对本文有异议

文章首发

【重学C++】01| C++ 如何进行内存资源管理?

前言

大家好,我是只讲技术干货的会玩code,今天是【重学C++】的第一讲,我们来学习下C++的内存管理。

与java、golang等自带垃圾回收机制的语言不同,C++并不会自动回收内存。我们必须手动管理堆上内存分配和释放,这往往会导致内存泄漏和内存溢出等问题。而且,这些问题可能不会立即出现,而是运行一段时间后,才会暴露出现,排查也很困难。因此,了解和掌握C++中的内存管理技巧和工具是非常重要的,可以提高程序性能、减少错误和增加安全性。

内存分区

在C++中,将操作系统分配给程序的内存空间按照用途划分了代码段、数据段、栈、堆几个不同的区域,每个区域都有其独特的内存管理机制。

代码区

代码区是用于存储程序代码的区域,代码段在程序真正执行前就被加载到内存中,在程序执行期间,代码区内存不会被修改和释放。

由于代码区是只读的,所以会被多个进程共享。在多个进程同时执行同一个程序时,操作系统只需要将代码段加载到内存中一次,然后让多个进程共享这个内存区域即可。

数据段

数据段用于存储静态全局变量、静态局部变量和静态常量等静态数据。在程序运行期间,数据段的大小固定不变,但其内容可以被修改。按照变量是否被初始化。数据段可分为已初始化数据段和未初始化数据段。

C++中函数调用以及函数内的局部变量的使用,都是通过栈这个内存分区实现的。栈分区由操作系统自动分配和释放,是一种"后进先出"的一种内存分区。每个栈的大小是固定的,一般只有几MB,所以如果栈变量太大,或者函数调用嵌套太深,容易发生栈溢出(stack overflow)。

先来一段示例代码,看看C++是如何使用栈进行使用栈来进行函数调用的。

  1. #include <iostream>
  2. void inner(int a) {
  3. std::cout << a << std::endl;
  4. }
  5. void outer(int n) {
  6. int a = n + 1;
  7. inner(a);
  8. }
  9. int main() {
  10. outer(4);
  11. }

上面这段代码运行过程中的栈变化如下图
image.png

每当程序调用一个函数时,该函数的参数、局部变量和返回地址等信息会被压入栈中。当函数执行完毕,再将这些信息从栈中弹出。根据之前压入的外层调用者压入栈的返回地址,返回到外层调用者未执行的代码继续执行。

本地变量是直接存储在栈上的,当函数执行完成后,这些变量占用的内存就会被释放掉了。前面例子中的本地变量是简单类型,在C++中称为POD类型。对于带有构造和析构函数的非POD类型变量,栈上的内存分配同样有效。编译器会在合适的时机,插入对构造函数和析构函数的调用。

这里有个问题,当函数执行发生异常时,析构函数还会被调用吗?
答案是会的,C++对于发生异常时对析构函数的调用称为"栈展开"。通过下面这段代码演示栈展开。

  1. #include <iostream>
  2. #include <string>
  3. class Obj {
  4. public:
  5. std::string name_;
  6. Obj(const std::string& name):name_(name){std::cout << "Obj() " << name_ << std::endl;};
  7. ~Obj() {std::cout << "~Obj() " << name_ << std::endl;};
  8. };
  9. void bar() {
  10. auto o = Obj{"bar"};
  11. throw "bar exception";
  12. }
  13. int main() {
  14. try {
  15. bar();
  16. } catch (const char* e) {
  17. std::cout << "catch Exception: " << e << std::endl;
  18. }
  19. }

执行代码的结果是:

  1. Obj() bar
  2. ~Obj() bar
  3. catch Exception: bar exception

可以发现,发生异常时,bar函数中的本地变量o还是能被正常析构。

栈展开的过程实际上是异常发生时,匹配catch子句的过程。

  1. 程序抛出异常,停止当前执行的调用链,开始寻找与异常匹配的catch子句。
  2. 如果异常发生在try中,则会首先检查与该try块匹配的catch子句。如果异常所在函数体没有try捕获异常。则会直接进入下一步。
  3. 如果第二步未找到匹配的catch,则会在外层的try块中查找,直到找到为止。
  4. 如果到了最外层还没有找到匹配的catch,也就是说异常得不到处理,程序会调用标准库函数terminate终止函数的执行。

在这期间,栈上所有的对象都会被自动析构。

堆是C++中用来存储动态分配内存的内存分区,堆内存的分配和释放需要手动管理,可以通过new/delete或malloc/free等函数进行分配和释放。堆内存的大小通常是不固定的,当我们需要动态分配内存时,就可以使用堆内存。

堆内存由程序员手动分配和释放,因此使用堆内存需要注意内存泄漏和内存溢出等问题。当程序员忘记释放已分配的内存时,会导致内存泄漏问题。而当申请的堆内存超过了操作系统所分配给进程的内存限制时,会导致内存溢出问题。

C++程序绝大多数的内存泄露,都是由于忘记调用delete/free来释放堆上的资源。

还是上代码

  1. #include <iostream>
  2. #include <string>
  3. class Obj {
  4. public:
  5. std::string name_;
  6. Obj(const std::string& name):name_(name){std::cout << "Obj() " << name_ << std::endl;};
  7. ~Obj() {std::cout << "~Obj() " << name_ << std::endl;};
  8. };
  9. Obj* makeObj() {
  10. Obj* obj = nullptr;
  11. try {
  12. obj = new Obj{"makeObj"};
  13. ...
  14. } catch(...) {
  15. delete obj;
  16. throw;
  17. }
  18. return obj;
  19. }
  20. Obj* foo() {
  21. Obj* obj = nullptr;
  22. try {
  23. obj = makeObj();
  24. ...
  25. } catch(...) {
  26. delete obj;
  27. }
  28. return obj;
  29. }
  30. int main() {
  31. Obj* obj = foo();
  32. ...
  33. delete obj;
  34. }

可以看到,由makeObj函数创建的堆变量obj, 在每个获取该变量的上层调用中,都需要关心对该变量的处理。这无疑极大得增加了开发者的心智负担。

RAII

想在堆上创建对象,又不想处理这么复杂的内存释放操作。C++没有像java、golang其他语言创建一套垃圾回收机制,而是采用了一种特有的资源管理方式 --- RAII(Resource Acquisition Is Initialization,资源获取即初始化)。

RAII利用栈对象在作用域结束后会自动调用析构函数的特点,通过创建栈对象来管理资源。在栈对象构造函数中获取资源,在栈对象析构函数中负责释放资源,以此保证资源的获取和释放。

下面给出一个通过RAII来自动释放堆内存的例子

  1. #include <iostream>
  2. class AutoIntPtr {
  3. public:
  4. AutoIntPtr(int* p = nullptr) : ptr(p) {}
  5. ~AutoIntPtr() { delete ptr; }
  6. int& operator*() const { return *ptr; }
  7. int* operator->() const { return ptr; }
  8. private:
  9. int* ptr;
  10. };
  11. void foo() {
  12. AutoIntPtr p(new int(5));
  13. std::cout << *p << std::endl; // 5
  14. }
  15. int main() {
  16. foo();
  17. }

上面例子中,AutoIntPtr类封装了一个动态分配的int类型的指针,它的构造函数用于获取资源(ptr = p),析构函数用于释放资源(delete ptr)。当AutoIntPtr超出作用域时,自动调用析构函数来释放所包含的资源。

基于RAII,C++11引入了std::unique_ptrstd::shared_ptr等智能指针用于内存管理类,使得内存管理变得更加方便和安全。这些内存管理类可以自动进行内存释放,避免了手动释放内存的繁琐工作。值得一提的是,上面的AutoIntPtr就是一个简化版的智能指针了。

在实际开发中,RAII的应用很广。不仅仅用于自动释放内存。还可以用来关闭文件、释放数据库连接、释放同步锁等。

总结

本文介绍了C++中的内存管理机制,包括内存分区、栈、堆和RAII技术等内容。通过学习本文,我们可以更好地掌握C++的内存管理技巧,避免内存泄漏和内存溢出等问题。

原文链接:https://www.cnblogs.com/huiwancode/p/17417705.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号