目录
1,shared_ptr和make_shared
(1)基本用法
#include<iostream>
#include <c++/memory>
using namespace std;
class A
{
public:
~A()
{
cout<<" des ";
}
};
int main()
{
shared_ptr<A>p=make_shared<A>(A());
shared_ptr<A>p2=p;
cout<<p.use_count();
return 0;
}
输出: des 2 des
共享的智能指针,shared_ptr其实是模板类,成员use_count就是引用次数,
当指针(其实是shared_ptr的实例)的生命周期结束之后,析构函数被自动调用,于是计数会自动减1
当引用次数减到0的时候,指向的对象会被自动删除。
上述代码之所以调用了2次析构函数,是因为模板函数make_shared传参。
另外一种写法:
int main()
{
shared_ptr<A>p(new A());
shared_ptr<A>p2=p;
cout<<p.use_count();
return 0;
}
输出: 2 des
(2)在函数中的传递
#include<iostream>
#include<vector>
using namespace std;
class A
{
public:
~A()
{
cout << " des ";
}
};
vector< shared_ptr<A>>v;
void f(shared_ptr<A>p)
{
v.push_back(p);
}
void f2()
{
shared_ptr<A>p = make_shared<A>(A());
cout << p.use_count();
f(p);
}
int main()
{
f2();
cout << " v.size=" << v.size();
return 0;
}
输出 des 1 v.size=1 des
说明f2函数退出的时候,智能指针还在,因为它被全局变量v引用了,直到main函数退出才销毁智能指针。
(3)在stl中的嵌套使用
#include<iostream>
#include<map>
#include<vector>
using namespace std;
class A
{
public:
~A()
{
cout << "des A";
}
};
int main()
{
shared_ptr<A>p = make_shared<A>(A());
cout << "\nnext\n";
map<int, vector<shared_ptr<A>>>m;
m[1].emplace_back(p);
m.erase(1);
return 0;
}
输出:
des A
next
des A
所以在map的erase时,会析构vector,所以会析构其中的每一个指针指针。
2,unique_ptr和make_unique
(1)基本用法
#include<iostream>
#include <c++/memory>
using namespace std;
class A
{
public:
int x=3;
~A()
{
cout<<" des ";
}
};
int main()
{
unique_ptr<A>p=make_unique<A>(A());
// unique_ptr<A>p2=p;
unique_ptr<A>p2=move(p);
// cout<<p->x;
cout<<p2->x;
return 0;
}
输出: des 3 des
另外一种写法:
int main()
{
unique_ptr<A>p(new A());
// unique_ptr<A>p2=p;
unique_ptr<A>p2=move(p);
// cout<<p->x;
cout<<p2->x;
return 0;
}
独占的智能指针,只能移动,不能拷贝,
unique_ptr的源码是这么写的:
// Disable copy from lvalue.
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
(2)被指向类的析构函数
如果被指向类没有构造函数,但是也没有调用:
class A {
public:
A()=delete;
public:
int x;
};
class B {
public:
std::unique_ptr<A> aiModel_;
int x;
};
int main()
{
B b;
cout << b.x;
return 0;
}
这是可以编译运行的。
但如果是:
class A {
public:
A()=delete;
~A()=delete;
public:
int x;
};
class B {
public:
std::unique_ptr<A> aiModel_;
int x;
};
int main()
{
B b;
cout << b.x;
return 0;
}
则会编译失败,即unique_ptr一定是需要被指向类有析构函数。
3,auto_ptr
auto_ptr是古老的智能指针,基本被抛弃了,
auto_ptr也是用来实现自动析构的,它是不计数的,在复制或者赋值的时候都会实现move语义,不符合直觉,所以被抛弃了。
auto_ptr的使用场景应该是被shared_ptr和unique_ptr瓜分了。
4,weak_ptr
weak_ptr有点像shared_ptr的副本,用来解决shared_ptr的引用成环的问题。
可以用weak_ptr或者shared_ptr的指针给weak_ptr的指针赋值,weak_ptr只能读取不能修改,也不参与计数。