一.智能指针的设计思路
- 智能指针是类模板，再栈上创建智能指针对象。
- 把普通指针交给智能指针对象。
- 智能指针对象过期时，调用析构函数释放普通指针的内存。
- 智能指针的类型
- auto_ptr是C++98的标准，c++17已经弃用。
- unique_ptr、shared_ptr和weak_ptr是C++11标准的。
二.智能指针 unique_ptr
C++智能指针unique_ptr是C++11标准库中提供的一种智能指针类型，用于管理动态分配的资源，主要用来避免内存泄漏和简化资源管理。unique_ptr是独占所有权的智能指针，即同一时间只能有一个unique_ptr指向特定的资源，当unique_ptr被销毁时，它所管理的资源会被自动释放。
1.基本用法
- 方法1：
unique_ptr<AA>p0(new AA("小明"));//分配内存并初始化
- 方法2：
unique_ptr<AA>p0=make_unique<AA>("小明");//c++14标准
- 方法3：
AA*p=new AA("小明");
unique_ptr<AA>p0(p);//用已存在的地址初始化
- 方法4：get()方法可以返回裸指针
2. 基本定义
- 包含头文件
#include <memory>
以下是unique_ptr的简化版本的类模板定义（省略了部分实现细节）：
template <typename T>
class unique_ptr {
private:
T* ptr;
public:
// 构造函数
unique_ptr(T* p) : ptr(p) {}
// 移动构造函数
unique_ptr(unique_ptr&& other) noexcept : ptr(other.ptr) {
other.ptr = nullptr;
}
// 析构函数
~unique_ptr() {
delete ptr;
}
// 禁止拷贝和赋值
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
// 移动赋值运算符
unique_ptr& operator=(unique_ptr&& other) noexcept {
if (this != &other) {
delete ptr;
ptr = other.ptr;
other.ptr = nullptr;
}
return *this;
}
// 获取裸指针
T* get() const {
return ptr;
}
// 重载运算符->
T* operator->() const {
return ptr;
}
// 重载解引用运算符*
T& operator*() const {
return *ptr;
}
// 释放资源
void reset() {
delete ptr;
ptr = nullptr;
}
};
3.实战测试
#include<iostream>
using namespace std;
#include<vector>
#include<memory>//智能指针头文件
class AA
{
public:
string m_name;
AA():m_name("未定义") { cout << m_name << "调用构造函数AA()" << endl; }
AA(const string& name) :m_name(name) { cout << "调用构造函数（" << m_name << ")" << endl; }
~AA() { cout << "调用了析构函数~AA(" << m_name << ")" << endl; }
};
int main()
{
AA* p1 = new AA("小明");
//使用智能指针来管理p
//这里AA的意思是要管理的普通指针类型是AA
//智能指针本来就是用来管理指针的所以不需要使用AA*
unique_ptr<AA>ptr1(p1);
//与正常指针用法一致
cout << "m_name " << (*ptr1).m_name << endl;
cout << "m_name " << ptr1->m_name << endl;
cout << "m_name " << (*p1).m_name << endl;
cout << "m_name " << p1->m_name << endl;
//system("pause");不能使用这个，否则程序无法正常关闭，析构函数无法成功调用
return 0;
}
- 执行结果
三.智能指针 shared_ptr
在 C++ 中，智能指针是一种用于管理动态分配对象的指针类，可以帮助开发人员更好地管理内存资源，避免内存泄漏等问题。std::shared_ptr 是 C++11 标准库中提供的一种智能指针，用于共享所有权的指针管理。std::shared_ptr 可以自动追踪有多少个指针共享同一个对象，并在对象不再被引用时安全地释放内存。共享指针的引用计数会在创建、复制和销毁时进行递增和递减，当引用计数为 0 时，内存资源就会被释放。
使用方法:(和unique_ptr基本一样的)
#include <memory>
std::shared_ptr<int> sharedPtr = std::make_shared<int>(10);
智能指针的复制:
std::shared_ptr<int> sharedPtr2 = sharedPtr;
使用 std::make_shared 创建对象时，可以减少内存分配和额外的虚拟函数调用。
可以使用 .use_count() 方法获取当前共享指针的引用计数。
std::shared_ptr 还支持自定义的删除器，用于指定释放内存时的操作。
总的来说，std::shared_ptr 可以帮助避免潜在的内存泄漏和悬空指针问题，提高代码的健壮性和可维护性。
- 实战测试
#include<iostream>
using namespace std;
#include<vector>
#include<memory>//智能指针头文件
class AA
{
public:
string m_name;
AA() :m_name("未定义") { cout << m_name << "调用构造函数AA()" << endl; }
AA(const string& name) :m_name(name) { cout << "调用构造函数（" << m_name << ")" << endl; }
~AA() { cout << "调用了析构函数~AA(" << m_name << ")" << endl; }
};
int main()
{
AA* p1 = new AA("小明");
//使用智能指针来管理p
//这里AA的意思是要管理的普通指针类型是AA
//智能指针本来就是用来管理指针的所以不需要使用AA*
shared_ptr<AA>ptr1(p1);
//与正常指针用法一致
cout << "m_name " << (*ptr1).m_name << endl;
cout << "m_name " << ptr1->m_name << endl;
cout << "m_name " << (*p1).m_name << endl;
cout << "m_name " << p1->m_name << endl;
cout << "use_count=" << ptr1.use_count() << endl;
//system("pause");不能使用这个，否则程序无法正常关闭，析构函数无法成功调用
return 0;
}
- 输出结果
四.智能指针 weak_ptr
在 C++ 中，std::weak_ptr 是另一种智能指针，用于解决 std::shared_ptr 循环引用所带来的问题。std::weak_ptr 允许你观察指向的对象，但不拥有其所有权。通常与 std::shared_ptr 一起使用，可以避免循环引用导致的内存泄漏问题。
以下是一些关于 std::weak_ptr 的重要点和用法：
- 通过 std::weak_ptr 对象获std::shared_ptr 对象：
std::shared_ptr<int> sharedPtr = std::make_shared<int>(10);
std::weak_ptr<int> weakPtr = sharedPtr;
- 使用 std::lock_guard 和 std::shared_ptr::lock 方法来安全地获取 std::shared_ptr 对象，避免访问已经释放的对象：
if (std::shared_ptr<int> sharedPtr = weakPtr.lock()) {
// 使用 sharedPtr 访问对象
} else {
// 对象已被释放
}
-
std::weak_ptr 不增加引用计数，只是提供了对对象的观察能力，也不会阻止对象的释放。
-
可以使用 std::weak_ptr 来打破循环引用，让对象能够被正确地释放。
std::weak_ptr 是一种很有用的工具，可以帮助解决在使用智能指针时可能会遇到的循环引用问题，确保内存资源能够正确地释放，提高程序的稳定性和可靠性。
- 实战测试
#include<iostream>
using namespace std;
#include<vector>
#include<memory>//智能指针头文件
class BB;
class AA
{
public:
string m_name;
AA() :m_name("未定义") { cout << m_name << "调用构造函数AA()" << endl; }
AA(const string& name) :m_name(name) { cout << "调用构造函数（" << m_name << ")" << endl; }
~AA() { cout << "调用了析构函数~AA(" << m_name << ")" << endl; }
shared_ptr<BB>p_B;
};
class BB
{
public:
string m_name;
BB() :m_name("未定义") { cout << m_name << "调用构造函数BB()" << endl; }
BB(const string& name) :m_name(name) { cout << "调用构造函数（" << m_name << ")" << endl; }
~BB() { cout << "调用了析构函数~BB(" << m_name << ")" << endl; }
shared_ptr<AA>p_A;
};
int main()
{
AA* p1 = new AA("小明");
BB* p2 = new BB("李华");
//使用智能指针来管理p
//这里AA的意思是要管理的普通指针类型是AA
//智能指针本来就是用来管理指针的所以不需要使用AA*
shared_ptr<AA>ptr1(p1);
shared_ptr<BB>ptr2 (p2);
//与正常指针用法一致
cout << "ptr1->m_name " << (*ptr1).m_name << endl;
cout << "ptr1->m_name " << ptr1->m_name << endl;
cout << "ptr1->m_name " << (*p1).m_name << endl;
cout << "ptr1->m_name " << p1->m_name << endl;
cout << "ptr1->use_count=" << ptr1.use_count() << endl;
cout << "ptr2->m_name " << (*ptr2).m_name << endl;
cout << "ptr2->m_name " << ptr2->m_name << endl;
cout << "ptr2->m_name " << (*p2).m_name << endl;
cout << "ptr2->m_name " << p2->m_name << endl;
cout << "ptr2->use_count=" << ptr2.use_count() << endl;
ptr1->p_B = ptr2;
ptr2->p_A = ptr1;
//system("pause");不能使用这个，否则程序无法正常关闭，析构函数无法成功调用
return 0;
}
-
由于相互执行都在等待对方释放资源，结果两方都无法释放资源
-
解决方法：使用weak_ptr
