文章目录

• • • unique_ptr
    • • 基本使用
      • 创建空的unique_ptr对象
      • new一个unique_ptr对象
      • make_unique创建unique_ptr对象
      • 获取被管理对象的指针
      • 重置 unique_ptr 对象
      • 转移 unique_ptr 对象的所有权
      • 释放关联的原始指针
      • 总结
      • 完整代码

unique_ptr

unique_ptr 是 C++ 11 提供的用于防止内存泄漏的智能指针中的一种实现

基本使用

#include <iostream>
#include <memory>

struct Task {
    int mId;
    Task(int id) :mId(id) {
        std::cout << "Task::Constructor" << std::endl;
    }
    ~Task() {
        std::cout << "Task::Destructor" << std::endl;
    }
};

int main()
{
    // 通过原始指针创建 unique_ptr 实例
    std::unique_ptr<Task> taskPtr(new Task(23));
    //通过 unique_ptr 访问其成员
    int id = taskPtr->mId;
    std::cout << id << std::endl;
    return 0;
}

在return0之后自动调用析构函数释放内存

Task::Constructor
23
Task::Destructor

unique_ptr <Task> 对象 taskPtr 接受原始指针作为参数。现在当main函数退出时，该对象超出作用范围就会调用其析构函数，在unique_ptr对象taskPtr 的析构函数中，会删除关联的原始指针，这样就不用专门delete Task对象了

创建空的unique_ptr对象

std::unique_ptr<int> ptr1;

判断unique_ptr 对象是否为空或者是否有与之关联的原始指针

// 方法1
if(!ptr1)
	std::cout<<"ptr1 is empty"<<std::endl;
// 方法2
if(ptr1 == nullptr)
	std::cout<<"ptr1 is empty"<<std::endl;

new一个unique_ptr对象

	std::unique_ptr<Task> taskPtr(new Task(22));
    //std::unique_ptr<Task> taskPtr2 = new Task(); // 编译错误

make_unique创建unique_ptr对象

std::make_unique<>() 是C++ 14 引入的新函数

std::unique_ptr<Task> taskPtr = std::make_unique<Task>(34);

获取被管理对象的指针

sdt::unique_ptr::get();

    std::unique_ptr<Task> taskPtr = std::make_unique<Task>(34);
    Task* p1 = taskPtr.get();
    std::cout << p1->mId << std::endl;

重置 unique_ptr 对象

taskPtr.reset();

转移 unique_ptr 对象的所有权

// 通过原始指针创建 taskPtr2
std::unique_ptr<Task> taskPtr2(new Task(55));
// 把taskPtr2中关联指针的所有权转移给taskPtr4
std::unique_ptr<Task> taskPtr4 = std::move(taskPtr2);
// 现在taskPtr2关联的指针为空
if(taskPtr2 == nullptr)
	std::cout<<"taskPtr2 is  empty"<<std::endl;

// taskPtr2关联指针的所有权现在转移到了taskPtr4中
if(taskPtr4 != nullptr)
	std::cout<<"taskPtr4 is not empty"<<std::endl;

// 会输出55
std::cout<< taskPtr4->mId << std::endl;

std::move() 将把 taskPtr2 转换为一个右值引用。因此，调用 unique_ptr 的移动构造函数，并将关联的原始指针传输到 taskPtr4。在转移完原始指针的所有权后， taskPtr2将变为空。

释放关联的原始指针

在 unique_ptr 对象上调用 release()将释放其关联的原始指针的所有权，并返回原始指针。这里是释放所有权，并没有delete原始指针，reset()会delete原始指针。

std::unique_ptr<Task> taskPtr5(new Task(55));
// 不为空
if(taskPtr5 != nullptr)
	std::cout<<"taskPtr5 is not empty"<<std::endl;
// 释放关联指针的所有权
Task * ptr = taskPtr5.release();
// 现在为空
if(taskPtr5 == nullptr)
	std::cout<<"taskPtr5 is empty"<<std::endl;

总结

1. 智能指针管理的是堆上面的指针，（栈上面的地址会造成两次调用析构）
2. shared_ptr相当于一个指针，拷贝和赋值会是的引用加一

std::shared_ptr<Person> p1(new Person(1));	// Person(1)的引用计数为1
std::shared_ptr<Person> p3 = p1;//现在p1和p3同时指向Person(1)，Person(3)的引用计数为2
std::cout<<p3.use_count()<<std::endl;	//引用计数为2
std::cout<<p1.use_count()<<std::endl;	//引用计数为2

3. 只有当引用计数为0时，才会释放内存

/*接上面的代码*/
p1.reset();	//Person(1)的引用计数为1
//p3.reset();//Person(1)的引用计数为0，析构Person(3)
//只重置p1，不重置p3，内存不会释放

完整代码

#include <iostream>
#include <memory>

using namespace std;
class Person
{
public:
    Person(int v) {
        value = v;
        std::cout << "Cons" <<value<< std::endl;
    }
    ~Person() {
        std::cout << "Des" <<value<< std::endl;
    }
    int value;
};

int main()
{
    std::shared_ptr<Person> p1(new Person(1));	// Person(1)的引用计数为1

    std::shared_ptr<Person> p2 = std::make_shared<Person>(2);

    p1.reset(new Person(3));// 首先生成新对象，然后引用计数减1，引用计数为0，故析构Person(1)
    // 最后将新对象的指针交给智能指针

    std::shared_ptr<Person> p3 = p1;//现在p1和p3同时指向Person(3)，Person(3)的引用计数为2
	std::cout<<p3.use_count()<<std::endl;
	std::cout<<p1.use_count()<<std::endl;

    p1.reset();//Person(3)的引用计数为1
    //p3.reset();//Person(3)的引用计数为0，析构Person(3)
    std::cout<<"over"<<std::endl;
    return 0;
}

Cons1
Cons2
Cons3
Des1
2
2
over
Des3
Des2

关于子类继承父类，智能指针引用匿名函数lambda解决