C++指针指针----unique_ptr
文章目录
[*]
[*]
[*]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 isempty"<<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;
总结
成员函数作用reset()重置unique_ptr为空，delete其关联的指针。release()不delete关联指针，并返回关联指针。释放关联指针的所有权，unique_ptr为空。get()仅仅返回关联指针use_count()获取引用计数std作用std::make_unique创建 unique_ptr 对象C++14std::move()对象转移
[*]智能指针管理的是堆上面的指针，（栈上面的地址会造成两次调用析构）
[*]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
[*]只有当引用计数为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解决
页:
[1]