目录
2.3.3std::unique_ptr 替代 std::auto_ptr
（图像由AI生成）
0.前言
在前面的博客中，我们探讨了C++11的新特性，比如列表初始化、auto关键字、decltype等。今天，我们将深入讨论C++11的智能指针，这是一种现代C++编程中非常重要的资源管理工具。智能指针可以帮助我们更好地管理内存，避免内存泄漏和其他潜在的资源管理问题。
1.为什么需要智能指针
在C++编程中，手动管理内存是一项复杂且容易出错的任务。忘记释放内存会导致内存泄漏，而重复释放内存则会导致未定义行为。智能指针通过自动管理动态分配的内存生命周期，极大地降低了这些风险。以下通过分析一个例子来展示传统指针可能导致的问题，以及智能指针如何解决这些问题。
下面是一个包含内存管理问题的代码示例：
#include <iostream>
#include <stdexcept>
int div()
{
int a, b;
std::cin >> a >> b;
if (b == 0)
throw std::invalid_argument("除0错误");
return a / b;
}
void Func()
{
// 1. 如果p1这里new 抛异常会如何?
// 2. 如果p2这里new 抛异常会如何?
// 3. 如果div()调用时发生异常会如何?
int* p1 = new int;
int* p2 = new int;
std::cout << div() << std::endl;
delete p1;
delete p2;
}
int main()
{
try
{
Func();
}
catch (const std::exception& e)
{
std::cout << e.what() << std::endl;
}
return 0;
}
问题分析：上面的代码中存在以下内存管理问题：
-
new 抛异常时的处理：
- 如果在
new int分配内存时抛出异常，后续的内存释放操作将不会执行，导致内存泄漏。 - 例如，如果
p1分配成功但p2分配失败，则p1分配的内存将不会被释放。
- 如果在
-
函数
div()抛异常时的处理：- 如果在调用
div()函数时抛出异常，如输入的除数为0，程序将直接跳转到catch块，而跳过了内存释放操作，导致内存泄漏。 - 此时，
p1和p2分配的内存都将不会被释放。
- 如果在调用
为了避免上述问题，我们可以使用C++11引入的智能指针，如std::unique_ptr和std::shared_ptr。智能指针通过RAII机制，确保在离开作用域时自动释放内存。
#include <iostream>
#include <stdexcept>
#include <memory>
int div()
{
int a, b;
std::cin >> a >> b;
if (b == 0)
throw std::invalid_argument("除0错误");
return a / b;
}
void Func()
{
std::unique_ptr<int> p1 = std::make_unique<int>();
std::unique_ptr<int> p2 = std::make_unique<int>();
std::cout << div() << std::endl;
}
int main()
{
try
{
Func();
}
catch (const std::exception& e)
{
std::cout << e.what() << std::endl;
}
return 0;
}
通过使用std::unique_ptr，我们可以避免内存泄漏的问题：
-
异常安全：
- 如果在
std::make_unique<int>()分配内存时抛出异常，智能指针会自动清理已分配的内存。 - 无论是在创建智能指针时还是在函数调用期间抛出异常，智能指针都会确保其管理的内存被正确释放。
- 如果在
-
自动内存管理：
- 智能指针在离开其作用域时会自动调用
delete释放内存，无需显式调用delete，避免了手动管理内存的繁琐和出错的可能。
- 智能指针在离开其作用域时会自动调用
2.智能指针的使用及原理
2.1RAII
RAII（Resource Acquisition Is Initialization，资源获取即初始化）是一种常见的C++编程惯用法，用于管理资源（如内存、文件句柄、网络连接等）的生命周期。RAII的核心思想是将资源的获取和释放绑定到对象的生命周期上。具体来说，当对象创建时获取资源，在对象销毁时自动释放资源。
RAII的优势在于：
- 异常安全：即使在出现异常的情况下，RAII对象也能确保资源被正确释放。
- 简化资源管理：通过自动管理资源的获取和释放，减少了手动管理资源的复杂性和错误风险。
以下是一个使用RAII管理文件资源的简单示例：
#include <iostream>
#include <fstream>
class FileRAII {
public:
FileRAII(const std::string& filename) {
file.open(filename);
if (!file.is_open()) {
throw std::runtime_error("Failed to open file");
}
}
~FileRAII() {
if (file.is_open()) {
file.close();
}
}
void write(const std::string& data) {
file << data;
}
private:
std::ofstream file;
};
int main() {
try {
FileRAII file("example.txt");
file.write("Hello, RAII!");
} catch (const std::exception& e) {
std::cerr << e.what() << std::endl;
}
return 0;
}
在这个示例中，FileRAII类在构造函数中打开文件，在析构函数中关闭文件。即使在文件操作过程中抛出异常，析构函数也会被调用，确保文件被正确关闭。
2.2智能指针的原理
智能指针是C++11引入的用于自动管理动态内存的工具。智能指针通过RAII机制，在对象生命周期内自动管理动态内存的分配和释放。C++11提供了三种主要的智能指针：std::unique_ptr、std::shared_ptr和std::weak_ptr。
2.2.1 std::unique_ptr
std::unique_ptr是独占所有权智能指针，即每个std::unique_ptr对象独占其管理的动态内存，不能复制，但可以移动。适用于明确需要单一所有权的场景。
#include <iostream>
#include <memory>
void uniquePtrExample() {
std::unique_ptr<int> p1 = std::make_unique<int>(10);
std::unique_ptr<int> p2 = std::move(p1); // p1所有权转移给p2
if (!p1) {
std::cout << "p1 is nullptr" << std::endl;
}
std::cout << "p2 value: " << *p2 << std::endl;
}
2.2.2 std::shared_ptr
std::shared_ptr是共享所有权智能指针，多个std::shared_ptr对象可以共享同一个动态内存。std::shared_ptr通过引用计数管理内存的释放。当最后一个std::shared_ptr销毁时，内存才会被释放。
#include <iostream>
#include <memory>
void sharedPtrExample() {
std::shared_ptr<int> p1 = std::make_shared<int>(10);
std::shared_ptr<int> p2 = p1; // p1和p2共享同一块内存
std::cout << "p1 use count: " << p1.use_count() << std::endl;
std::cout << "p2 use count: " << p2.use_count() << std::endl;
}
2.2.3 std::weak_ptr
std::weak_ptr与std::shared_ptr配合使用，不会影响引用计数。std::weak_ptr用于解决循环引用问题，防止内存泄漏。
#include <iostream>
#include <memory>
void weakPtrExample() {
std::shared_ptr<int> p1 = std::make_shared<int>(10);
std::weak_ptr<int> wp = p1; // wp不会增加引用计数
std::cout << "p1 use count: " << p1.use_count() << std::endl;
if (auto sp = wp.lock()) { // 需要使用时转换为shared_ptr
std::cout << "sp value: " << *sp << std::endl;
}
}
2.2.4智能指针的实现机制
智能指针通过运算符重载和模板机制，实现类似指针的行为，并在合适的时机自动释放内存。以下是智能指针的主要实现机制：
-
运算符重载：
- 智能指针重载了
*和->运算符，使其行为与原始指针类似，方便使用。 - 例如，
std::unique_ptr和std::shared_ptr都重载了*和->运算符，允许通过智能指针访问管理的对象。
- 智能指针重载了
-
引用计数：
std::shared_ptr通过内部的引用计数机制管理共享内存。当一个std::shared_ptr对象被复制时，引用计数增加；当一个std::shared_ptr对象被销毁时，引用计数减少。当引用计数减少到零时，内存被释放。std::weak_ptr不会增加引用计数，但可以通过lock方法安全地获取一个std::shared_ptr，以访问共享内存。
-
自定义删除器：
- 智能指针允许用户提供自定义删除器，定义在内存释放时需要执行的操作。这样可以处理特殊资源的释放需求。
- 例如，
std::unique_ptr和std::shared_ptr都支持自定义删除器。
2.3std::auto_ptr(C++98)及缺陷
std::auto_ptr是C++98标准引入的第一个智能指针，用于简化动态内存的管理。然而，由于其设计上的一些缺陷，std::auto_ptr在C++11中被弃用，并被更安全、更高效的std::unique_ptr取代。
2.3.1std::auto_ptr 的基本用法
std::auto_ptr的主要目的是在对象销毁时自动释放其管理的内存，避免内存泄漏。它使用非常简单，可以像原始指针一样操作，并且在超出作用域时会自动释放内存。
#include <iostream>
#include <memory>
void autoPtrExample() {
std::auto_ptr<int> p1(new int(10));
std::cout << *p1 << std::endl;
}
在上面的示例中，p1是一个std::auto_ptr，它管理着一个动态分配的int。当p1超出作用域时，内存会自动释放。
2.3.2std::auto_ptr 的缺陷
尽管std::auto_ptr在一定程度上简化了内存管理，但它存在几个显著的缺陷：
-
所有权转移（所有权语义）：
std::auto_ptr的最大问题在于它的所有权转移语义。在复制或赋值时，所有权会从源指针转移到目标指针，源指针会变为nullptr。这种行为容易导致意外的内存问题。- 例如：
std::auto_ptr<int> p1(new int(10)); std::auto_ptr<int> p2 = p1; // p1 的所有权转移给 p2，p1 变为 nullptr std::cout << *p2 << std::endl; // 正常输出 // std::cout << *p1 << std::endl; // 未定义行为，p1 已经是 nullptr -
容器兼容性差：
- 由于
std::auto_ptr的所有权转移语义，它不能安全地用于标准容器（如std::vector、std::list等）。在容器操作过程中复制或赋值会导致未定义行为。
- 由于
-
不符合现代C++标准：
std::auto_ptr不支持C++11及更高版本的特性，如移动语义和自定义删除器，这使其在现代C++编程中变得过时和不安全。
由于这些缺陷，std::auto_ptr在C++11中被弃用，取而代之的是std::unique_ptr和std::shared_ptr，它们提供了更安全、更灵活的内存管理机制。
2.3.3std::unique_ptr 替代 std::auto_ptr
std::unique_ptr是C++11标准中引入的智能指针，它克服了std::auto_ptr的缺陷，并且更符合现代C++编程的需求。
#include <iostream>
#include <memory>
void uniquePtrExample() {
std::unique_ptr<int> p1 = std::make_unique<int>(10);
std::unique_ptr<int> p2 = std::move(p1); // p1 的所有权转移给 p2，p1 变为 nullptr
if (!p1) {
std::cout << "p1 is nullptr" << std::endl;
}
std::cout << "p2 value: " << *p2 << std::endl;
}
与std::auto_ptr不同，std::unique_ptr通过显式的移动语义（使用std::move）来管理所有权的转移，避免了隐式所有权转移带来的问题。此外，std::unique_ptr也可以安全地用于标准容器，并支持自定义删除器，使其在现代C++编程中更加灵活和强大。
总之，std::auto_ptr作为早期的智能指针解决方案，虽然提供了自动内存管理的功能，但由于其设计上的缺陷，在现代C++编程中已经不再推荐使用。std::unique_ptr和std::shared_ptr等现代智能指针提供了更安全、更高效的替代方案。
3.shared_ptr模拟实现
3.1简单版本
以下是一个简单版本的shared_ptr实现，它包含了基本的引用计数机制和资源管理功能。该版本的shared_ptr能够管理动态分配的内存，并在最后一个指针销毁时自动释放内存。
#include <iostream>
using namespace std;
namespace wxk{
template<class T>
class shared_ptr
{
private:
T* ptr; // 管理的指针
int* count; // 引用计数
// 释放资源的函数
void release()
{
if (--(*count) == 0)
{
delete ptr;
delete count;
ptr = nullptr;
count = nullptr;
}
}
public:
// 构造函数
shared_ptr(T* p = nullptr) : ptr(p), count(new int(1)) {}
// 拷贝构造函数
shared_ptr(const shared_ptr& sp) : ptr(sp.ptr), count(sp.count)
{
++(*count);
}
// 赋值运算符重载
shared_ptr& operator=(const shared_ptr& sp)
{
if (ptr != sp.ptr)
{
release();
ptr = sp.ptr;
count = sp.count;
++(*count);
}
return *this;
}
// 析构函数
~shared_ptr()
{
release();
cout << "~shared_ptr()" << endl; // 测试析构函数是否被调用
}
// 重载解引用运算符
T& operator*() { return *ptr; }
// 重载成员访问运算符
T* operator->() { return ptr; }
// 返回引用计数
int use_count() { return *count; }
// 返回管理的指针
T* get() { return ptr; }
// 判断指针是否为空
operator bool() { return ptr; }
};
// 测试函数
void test_shared_ptr()
{
shared_ptr<int> sp1(new int(10));
cout << "sp1 use count: " << sp1.use_count() << endl;
{
shared_ptr<int> sp2 = sp1;
cout << "sp1 use count: " << sp1.use_count() << endl;
cout << "sp2 use count: " << sp2.use_count() << endl;
}
cout << "sp1 use count after sp2 out of scope: " << sp1.use_count() << endl;
cout << "sp1 value: " << *sp1 << endl;
}
}
int main()
{
wxk::test_shared_ptr();
return 0;
}输出结果：
sp1 use count: 1
sp1 use count: 2
sp2 use count: 2
~shared_ptr()
sp1 use count after sp2 out of scope: 1
sp1 value: 10
~shared_ptr()
3.2带自定义删除器版本
在简单版本的基础上，添加了自定义删除器功能。自定义删除器允许用户在删除资源时执行特定操作，而不仅仅是调用delete。
#include <iostream>
#include <functional>
using namespace std;
namespace wxk{
template<class T>
class shared_ptr
{
private:
T* ptr; // 管理的指针
int* count; // 引用计数
function<void(T*)> deleter = [](T* p) { delete p; }; // 默认删除器
// 释放资源的函数
void release()
{
if (--(*count) == 0)
{
deleter(ptr);
delete count;
ptr = nullptr;
count = nullptr;
}
}
public:
// 构造函数
shared_ptr(T* p = nullptr) : ptr(p), count(new int(1)) {}
// 带自定义删除器的构造函数
template<class D>
shared_ptr(T* p, D d) : ptr(p), count(new int(1)), deleter(d) {}
// 拷贝构造函数
shared_ptr(const shared_ptr& sp) : ptr(sp.ptr), count(sp.count), deleter(sp.deleter)
{
++(*count);
}
// 赋值运算符重载
shared_ptr& operator=(const shared_ptr& sp)
{
if (ptr != sp.ptr)
{
release();
ptr = sp.ptr;
count = sp.count;
deleter = sp.deleter;
++(*count);
}
return *this;
}
// 析构函数
~shared_ptr()
{
release();
cout << "~shared_ptr()" << endl; // 测试析构函数是否被调用
}
// 重载解引用运算符
T& operator*() { return *ptr; }
// 重载成员访问运算符
T* operator->() { return ptr; }
// 返回引用计数
int use_count() { return *count; }
// 返回管理的指针
T* get() { return ptr; }
// 判断指针是否为空
operator bool() { return ptr; }
// 重置管理的指针
void reset(T* p = nullptr)
{
release();
ptr = p;
count = new int(1);
}
// 带自定义删除器的重置函数
void reset(T* p, function<void(T*)> d)
{
release();
ptr = p;
count = new int(1);
deleter = d;
}
// 交换两个 shared_ptr 的内容
void swap(shared_ptr& sp)
{
std::swap(ptr, sp.ptr);
std::swap(count, sp.count);
std::swap(deleter, sp.deleter);
}
};
// 测试函数
void test_shared_ptr_with_deleter()
{
// 使用默认删除器
shared_ptr<int> sp1(new int(10));
cout << "sp1 use count: " << sp1.use_count() << endl;
{
// 使用自定义删除器
shared_ptr<int> sp2(new int(20), [](int* p) {
cout << "Custom deleter called for: " << *p << endl;
delete p;
});
cout << "sp2 use count: " << sp2.use_count() << endl;
shared_ptr<int> sp3 = sp2;
cout << "sp2 use count: " << sp2.use_count() << endl;
cout << "sp3 use count: " << sp3.use_count() << endl;
}
cout << "sp1 use count after sp2 and sp3 out of scope: " << sp1.use_count() << endl;
cout << "sp1 value: " << *sp1 << endl;
}
}
int main()
{
wxk::test_shared_ptr_with_deleter();
return 0;
}
输出结果：
sp1 use count: 1
sp2 use count: 1
sp2 use count: 2
sp3 use count: 2
~shared_ptr()
Custom deleter called for: 20
~shared_ptr()
sp1 use count after sp2 and sp3 out of scope: 1
sp1 value: 10
~shared_ptr()
4.内存泄漏
4.1内存泄漏的含义
内存泄漏（Memory Leak）是指在程序运行过程中，动态分配的内存未能被及时释放，导致这些内存块无法再次被分配使用。内存泄漏通常发生在程序员忘记释放已经不再使用的内存时。在长时间运行的程序中，内存泄漏会导致系统的可用内存逐渐减少，最终可能导致程序崩溃或系统性能显著下降。
4.2内存泄漏的危害
内存泄漏的危害主要体现在以下几个方面：
- 内存耗尽：持续的内存泄漏会导致系统内存逐渐耗尽，使得其他程序无法获得足够的内存资源，可能导致系统运行缓慢或崩溃。
- 性能下降：由于可用内存减少，系统可能需要频繁进行内存交换（swap），导致程序运行速度变慢，系统整体性能下降。
- 程序崩溃：当内存泄漏严重时，程序可能无法继续运行，导致崩溃。对于一些关键的应用程序，如服务器程序，这种崩溃可能带来严重的后果。
- 调试困难：内存泄漏通常是隐蔽的错误，可能在程序运行很长时间后才会显现出来，增加了调试和修复的难度。
4.3如何检测内存泄漏
检测内存泄漏的方法有很多，常见的工具和技术包括：
- 静态分析工具：这些工具在编译时分析代码，查找可能导致内存泄漏的代码路径。例如，Clang Static Analyzer。
- 动态分析工具：这些工具在程序运行时监测内存分配和释放情况，检测内存泄漏。例如，Valgrind、Dr. Memory、Visual Leak Detector。
- 内存调试器：一些开发环境和调试器提供内存调试功能，可以帮助发现内存泄漏。例如，Microsoft Visual Studio 的内存调试工具。
- 代码审查：通过代码审查，开发人员可以手动检查内存分配和释放的逻辑，发现潜在的内存泄漏问题。
- 日志记录：在代码中添加内存分配和释放的日志记录，可以帮助追踪内存使用情况，发现异常的内存使用模式。
4.4如何避免内存泄漏
为了避免内存泄漏，开发人员可以采取以下措施：
- 使用智能指针：C++11 引入的智能指针，如
std::unique_ptr、std::shared_ptr，通过 RAII 机制自动管理内存，确保在离开作用域时自动释放内存，从根本上避免内存泄漏。std::unique_ptr<int> ptr = std::make_unique<int>(10); - 遵循 RAII 原则：在资源管理类中使用 RAII（Resource Acquisition Is Initialization）原则，确保资源在对象的生命周期内自动释放。
- 及时释放资源：在不再需要使用的地方，及时释放动态分配的内存。
int* ptr = new int(10); // 使用 ptr delete ptr; - 避免循环引用：使用
std::shared_ptr时，避免循环引用，使用std::weak_ptr打破循环引用。std::shared_ptr<A> a = std::make_shared<A>(); std::shared_ptr<B> b = std::make_shared<B>(); a->b = b; b->a = a; // 造成循环引用，应该使用 std::weak_ptr - 使用标准库容器：使用标准库容器（如
std::vector、std::list等）管理动态分配的内存，这些容器在离开作用域时会自动释放所管理的内存。std::vector<int> vec; vec.push_back(10); vec.push_back(20);
5.结语
智能指针是C++11引入的重要特性，通过自动管理动态内存的生命周期，极大地减少了内存泄漏和资源管理的复杂性。理解并正确使用智能指针，如std::unique_ptr、std::shared_ptr和std::weak_ptr，是现代C++编程的重要技能。通过结合RAII原则和合适的工具，开发人员可以编写出更安全、高效、易维护的代码，从而提高程序的稳定性和可靠性。希望本文对智能指针的深入探讨能够帮助大家更好地掌握这一强大的编程工具。
1001
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
