当前位置： 首页 > article >正文

【C/C++】内存管理详解：从new/delete到智能指针的全面解析

article 2024/11/30 5:23:02

文章目录

    • 更多文章
    • C/C++中的传统内存管理方式
      • `new`和`delete`运算符
      • `malloc`和`free`函数
      • 传统内存管理的弊端
    • 智能指针的崛起
      • 智能指针的定义与作用
      • C++11引入的标准智能指针
    • 详解C++标准智能指针
      • `std::unique_ptr`
        • 特点
        • 使用方法
        • 适用场景
      • `std::shared_ptr`
        • 特点
        • 使用方法
        • 适用场景
      • `std::weak_ptr`
        • 特点
        • 使用方法
        • 适用场景
    • 智能指针与传统内存管理的比较
      • 内存安全性
      • 性能考量
      • 使用复杂度
    • 智能指针的最佳实践
      • 选择合适的智能指针类型
      • 避免循环引用
      • 与传统指针的混用
      • 避免不必要的拷贝
      • 使用`make_*`函数
    • 案例教程：使用智能指针管理内存
      • 传统方法实现
      • 使用`std::unique_ptr`重构
      • 使用`std::shared_ptr`的场景
    • 更多文章
  • 结语

更多文章

【OpenAI】获取OpenAI API Key的多种方式全攻略：从入门到精通，再到详解教程！！

【VScode】VSCode中的智能编程利器，全面揭秘ChatMoss & ChatGPT中文版

【体验最新的GPT系列模型！支持Open API调用、自定义助手、文件上传等强大功能，助您提升工作效率！点击链接体验：CodeMoss & ChatGPT-AI中文版】
在这里插入图片描述

C/C++中的传统内存管理方式

在深入探讨智能指针之前，我们首先需要了解C/C++中传统的内存管理方式，以便更好地理解智能指针的优势所在。

new和delete运算符

在C++中，new和delete是用于动态分配和释放内存的运算符。

// 使用new分配内存
int* ptr = new int;

// 使用delete释放内存
delete ptr;

通过new，程序员可以在堆上动态分配内存，而通过delete则可以手动释放这部分内存。然而，这种手动管理方式容易导致内存泄漏或悬挂指针等问题。

malloc和free函数

在C语言中，malloc和free函数用于动态内存分配和释放。

// 使用malloc分配内存
int* ptr = (int*)malloc(sizeof(int));

// 使用free释放内存
free(ptr);

malloc函数返回一个void*指针，需要通过类型转换来使用。与new/delete类似，malloc和free也需要开发者手动管理内存，同样面临内存泄漏和其他相关问题。

传统内存管理的弊端

虽然new/delete和malloc/free为程序员提供了灵活的内存管理方式，但其手动管理的特性也带来了诸多弊端：

  1. 内存泄漏：如果开发者忘记调用delete或者free释放内存，程序会出现内存泄漏，长时间运行后可能导致系统资源耗尽。
  2. 悬挂指针：在释放内存后，指针仍然指向原来的地址，如果再次访问可能导致未定义行为。
  3. 异常安全性差：在异常发生时，手动管理的内存释放往往难以保证，容易导致资源泄漏。
  4. 代码复杂度高：需要在多个地方进行内存分配和释放，增加了代码的复杂性和维护难度。

这些问题不仅影响程序的稳定性和性能，还增加了开发和调试的难度。因此，寻求一种更安全、更高效的内存管理方式成为现代C++开发的重要课题。

智能指针的崛起

为了应对传统内存管理方式的诸多问题，C++11标准引入了智能指针，作为一种RAII机制，旨在自动管理内存资源，减少内存泄漏和其他相关问题的发生。
在这里插入图片描述

智能指针的定义与作用

智能指针是一种封装了普通指针的类，通过自动管理内存的分配和释放，简化了内存管理的过程。它们利用独占或共享所有权的概念，确保在对象不再使用时，自动释放相关资源，从而提高代码的安全性和可维护性。

智能指针的主要作用包括：

  1. 自动内存管理：避免手动调用delete或free，减少内存泄漏的风险。
  2. 异常安全：在异常发生时，智能指针能够确保资源被正确释放。
  3. 所有权管理：通过不同类型的智能指针，管理资源的独占或共享所有权，提高代码的表达力和安全性。

C++11引入的标准智能指针

C++11标准引入了三种主要的标准智能指针，分别适用于不同的使用场景：

  1. std::unique_ptr：独占所有权，不能被复制，适用于资源的独占管理。
  2. std::shared_ptr：共享所有权，多个shared_ptr可以指向同一资源，通过引用计数管理资源的生命周期。
  3. std::weak_ptr：观察者指针，不增加引用计数，主要用于解决shared_ptr之间的循环引用问题。

这些智能指针的引入极大地简化了内存管理过程，提升了代码的安全性和可维护性。

详解C++标准智能指针

为了全面掌握智能指针的使用，以下将对C++11标准中的三种主要智能指针进行详细解析，包括其特点、使用方法及适用场景。

std::unique_ptr

特点
  • 独占所有权：unique_ptr拥有其所指向资源的独占所有权，不能被复制，只能被移动。
  • 轻量级：相比shared_ptr，unique_ptr更为轻量，适用于简单的资源管理场景。
  • 自动释放：当unique_ptr生命周期结束时，自动调用delete释放资源，避免内存泄漏。
使用方法
#include <memory>

void uniquePtrExample() {
    // 创建一个unique_ptr
    std::unique_ptr<int> ptr(new int(10));

    // 访问指针
    std::cout << "Value: " << *ptr << std::endl;

    // 转移所有权
    std::unique_ptr<int> ptr2 = std::move(ptr);

    if (!ptr) {
        std::cout << "ptr is now null." << std::endl;
    }
}
适用场景
  • 资源的独占管理：适用于资源不需要被多个对象共享的场景，如单一对象的内部资源。
  • RAII模式：在资源管理的RAII模式中，unique_ptr是首选工具。
  • 性能要求高的场景：由于unique_ptr无引用计数，适用于对性能有严格要求的场景。

【体验最新的GPT系列模型！支持Open API调用、自定义助手、文件上传等强大功能，助您提升工作效率！点击链接体验：CodeMoss & ChatGPT-AI中文版】
在这里插入图片描述

std::shared_ptr

特点
  • 共享所有权：多个shared_ptr可以共同指向同一资源，通过内部的引用计数机制管理资源的生命周期。
  • 引用计数机制：每一个shared_ptr的拷贝都会增加引用计数，销毁时会减少引用计数，当引用计数为零时，自动释放资源。
  • 灵活性高：适用于多个对象需要共同管理同一资源的场景。
使用方法
#include <memory>

void sharedPtrExample() {
    // 创建一个shared_ptr
    std::shared_ptr<int> ptr1 = std::make_shared<int>(20);

    {
        // 复制shared_ptr
        std::shared_ptr<int> ptr2 = ptr1;
        std::cout << "Value: " << *ptr2 << ", Use count: " << ptr1.use_count() << std::endl;
    }

    // ptr2超出作用域，引用计数减少
    std::cout << "Use count after ptr2 is destroyed: " << ptr1.use_count() << std::endl;
}
适用场景
  • 资源需要被多个对象共享：如共享的数据缓冲区、共享的资源池等。
  • 复杂的数据结构：如图结构、循环引用的场景（需要结合weak_ptr使用）。
  • 需要控制资源的生命周期：当资源的生命周期需要被多个部分共同管理时。

std::weak_ptr

特点
  • 非拥有性观察者指针：weak_ptr不拥有资源的所有权，不影响引用计数。
  • 防止循环引用：在shared_ptr间可能产生的循环引用场景中，通过weak_ptr打破循环，避免内存泄漏。
  • 访问资源需转换：要访问资源，需先将weak_ptr转换为shared_ptr，确保资源在访问期间不会被释放。
使用方法
#include <memory>

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev; // 使用weak_ptr避免循环引用
};

void weakPtrExample() {
    auto first = std::make_shared<Node>();
    auto second = std::make_shared<Node>();

    first->next = second;
    second->prev = first; // weak_ptr，不增加引用计数
}
适用场景
  • 打破循环引用：在涉及双向引用的数据结构中，如双向链表、图等。
  • 缓存系统：实现缓存时，weak_ptr可用于观察但不拥有缓存对象。
  • 临时访问：在需要临时访问资源但不希望延长其生命周期时。

智能指针与传统内存管理的比较

在了解了传统内存管理方式和智能指针的基本概念后，接下来将具体比较二者在内存安全性、性能和使用复杂度等方面的区别，为开发者选择合适的内存管理策略提供参考。

【体验最新的GPT系列模型！支持Open API调用、自定义助手、文件上传等强大功能，助您提升工作效率！点击链接体验：CodeMoss & ChatGPT-AI中文版】
在这里插入图片描述

内存安全性

传统方法：

  • 手动管理内存，容易出现内存泄漏、悬挂指针等问题。
  • 开发者需要严格遵循内存分配和释放的规范，增加了出错的可能性。

智能指针：

  • 自动管理内存，减少了人为忘记释放内存的风险。
  • 通过RAII机制，在对象生命周期结束时自动释放资源，提高了内存安全性。
  • weak_ptr有效防止了shared_ptr的循环引用问题。

性能考量

传统方法：

  • 无额外的性能开销，适用于对性能有极高要求的场景。
  • 但由于手动管理，错误释放内存可能导致不可预测的性能问题。

智能指针：

  • unique_ptr几乎无额外开销，适用于性能敏感的场景。
  • shared_ptr由于引用计数机制，存在一定的性能开销，尤其是在高频率的拷贝和销毁操作中。
  • weak_ptr本身开销较低，但在转换为shared_ptr时需要一定的计算。

使用复杂度

传统方法：

  • 灵活性高，但需要开发者手动管理，增加了代码的复杂性和出错概率。
  • 在复杂的应用场景中，维护手动管理的代码较为困难。

智能指针：

  • 提供了更高层次的抽象，简化了内存管理的流程。
  • 学习曲线相对较低，但需要理解不同智能指针的适用场景和使用方法。
  • 提高了代码的可读性和可维护性，减少了内存管理相关的出错概率。

智能指针的最佳实践

为了充分发挥智能指针的优势，开发者需要遵循一些最佳实践，合理选择和使用智能指针，避免潜在的问题。

选择合适的智能指针类型

  • std::unique_ptr：当资源拥有权是独占的，且不需要共享时，优先使用unique_ptr。它轻量且效率高，适合大多数独占资源的管理场景。

    std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();

  • std::shared_ptr：当资源需要被多个对象共享时，使用shared_ptr。确保没有不必要的共享所有权，以避免引用计数的额外开销。

    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
std::shared_ptr<MyClass> ptr2 = ptr1;

  • std::weak_ptr：在需要观察但不拥有资源的场景中使用，特别是在打破shared_ptr循环引用时。

    std::weak_ptr<MyClass> weakPtr = sharedPtr;

避免循环引用

在某些场景，如树形结构、双向链表等，shared_ptr可能导致循环引用，进而引发内存泄漏。此时，应结合weak_ptr使用，打破循环引用。

struct Parent;
struct Child;

struct Parent {
    std::shared_ptr<Child> child;
};

struct Child {
    std::weak_ptr<Parent> parent; // 使用weak_ptr避免循环引用
};

与传统指针的混用

尽可能避免混用智能指针与原始指针，尤其是在管理同一资源时。若确实需要使用原始指针，确保它们仅作为观察者存在，不参与所有权管理。

std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();
MyClass* rawPtr = ptr.get(); // 仅作为观察者使用

避免不必要的拷贝

对于shared_ptr，避免不必要的拷贝操作，尤其是在高频率的函数调用中，因为每一次拷贝都会增加和减少引用计数，带来性能开销。

// 不推荐
void function(std::shared_ptr<MyClass> ptr);

// 推荐
void function(const std::shared_ptr<MyClass>& ptr);

使用make_*函数

优先使用std::make_unique和std::make_shared等工厂函数创建智能指针，避免手动使用new，提高代码的安全性和可读性。

auto ptr = std::make_unique<MyClass>();
auto sptr = std::make_shared<MyClass>();

案例教程：使用智能指针管理内存

通过一个实际案例，展示传统内存管理方式与智能指针的应用差异，帮助读者直观理解智能指针的优势。

传统方法实现

假设我们需要实现一个简单的类Person，并在主函数中动态创建和管理Person对象。

#include <iostream>
#include <string>

class Person {
public:
    Person(const std::string& name) : name_(name) {
        std::cout << "Person " << name_ << " created." << std::endl;
    }

    ~Person() {
        std::cout << "Person " << name_ << " destroyed." << std::endl;
    }

    void greet() const {
        std::cout << "Hello, I am " << name_ << "." << std::endl;
    }

private:
    std::string name_;
};

int main() {
    // 动态分配Person对象
    Person* person = new Person("Alice");
    person->greet();

    // 忘记释放内存，导致内存泄漏
    // delete person;

    return 0;
}

问题：

  • 如果忘记调用delete person;，会导致内存泄漏。
  • 在异常发生时，delete可能无法被调用，进一步加剧内存泄漏的问题。

使用std::unique_ptr重构

通过使用std::unique_ptr，自动管理Person对象的生命周期，避免内存泄漏。

#include <iostream>
#include <string>
#include <memory>

class Person {
public:
    Person(const std::string& name) : name_(name) {
        std::cout << "Person " << name_ << " created." << std::endl;
    }

    ~Person() {
        std::cout << "Person " << name_ << " destroyed." << std::endl;
    }

    void greet() const {
        std::cout << "Hello, I am " << name_ << "." << std::endl;
    }

private:
    std::string name_;
};

int main() {
    {
        // 使用unique_ptr管理Person对象
        std::unique_ptr<Person> person = std::make_unique<Person>("Bob");
        person->greet();
    } // person超出作用域，自动调用delete

    return 0;
}

优势：

  • 自动释放内存，无需手动调用delete。
  • 即使在异常发生时，unique_ptr也能确保资源被正确释放。

使用std::shared_ptr的场景

假设我们有多个对象需要共享同一个Person对象，使用std::shared_ptr可以方便地管理共享所有权。

#include <iostream>
#include <string>
#include <memory>

class Person {
public:
    Person(const std::string& name) : name_(name) {
        std::cout << "Person " << name_ << " created." << std::endl;
    }

    ~Person() {
        std::cout << "Person " << name_ << " destroyed." << std::endl;
    }

    void greet() const {
        std::cout << "Hello, I am " << name_ << "." << std::endl;
    }

private:
    std::string name_;
};

void greetPerson(std::shared_ptr<Person> person) {
    person->greet();
}

int main() {
    // 使用shared_ptr管理Person对象
    std::shared_ptr<Person> person = std::make_shared<Person>("Charlie");
    greetPerson(person);
    std::cout << "Use count: " << person.use_count() << std::endl;

    return 0;
}

优势：

  • 通过shared_ptr，多个函数或对象可以共享同一个Person对象，而无需担心内存泄漏。
  • 当所有shared_ptr实例被销毁时，资源自动释放。

更多文章

【OpenAI】获取OpenAI API Key的多种方式全攻略：从入门到精通，再到详解教程！！

【VScode】VSCode中的智能编程利器，全面揭秘ChatMoss & ChatGPT中文版

结语

掌握内存管理不仅是C/C++开发者的必备技能，更是提升编程能力的重要一步。通过理解传统方法与智能指针的优劣，并灵活运用智能指针的各类工具，开发者能够编写出更加健壮、高效的代码，轻松应对复杂的开发挑战。希望本篇文章能够为你在内存管理的道路上提供有力的指导，助你在C/C++编程的世界中游刃有余。


http://www.kler.cn/a/415186.html

相关文章：

  • vitess使用记录：vtctldclient，设置分表规则
  • 微信小程序全局配置：TabBar与页面配置详解
  • podman 源码 5.3.1编译
  • 重学 Android 自定义 View 系列(八)：星星评分控件（RatingBar）
  • 百度智能云千帆部署流程---语音识别和合成
  • Hbase2.2.7集群部署
  • Leecode刷题C语言之单调数组对的数目②
  • scrapy豆瓣爬虫
  • 数据库原理-期末重要概念总结
  • 【亚马逊云科技】使用Amazon Lightsail搭建nginx服务
  • 自然语言能开发项目? 基于Agent的AI开发团队提示词分享
  • opencv 区域提取三种算法
  • HickWall 详解
  • llamaindex实战-ChatEngine-ReAct Agent模式
  • 剖析 SpringBoot 于夕阳红公寓管理系统架构搭建的核心作用
  • Excel小功能收集笔记-01
  • 如何将多个JS文件打包成一个JS文件？
  • [Go] slice切片详解
  • SQL：多字段混合去重后编号
  • [2024年3月10日]第15届蓝桥杯青少组stema选拔赛C++中高级（第二子卷、编程题（2））
  • 网安瞭望台第4期：nuclei最新poc分享
  • 算力100问☞第30问：密集计算有什么特点？
  • 电脑中的vcruntime140_1.dll文件有问题要怎么解决？一键修复vcruntime140_1.dll
  • 【力扣】541.反转字符串2
  • 银行卡OCR 识别 API 接口如何用PHP如何调用
  • 命令行使用ssh隧道连接远程mysql