RAII技术
RAII技术即资源分配及初始化,使用类来封装资源的分配和初始化,再构造函数完成资源的分配和初始化,析构函数完成资源的清理,可以保证正确的初始化和资源释放
智能指针
什么是智能指针?
智能指针是借用RAII技术对普通指针进行封装,实质是一个对象,表现为一个指针,即智能的管理动态资源的释放。
智能指针的作用
1.防止忘记调用delete操作符释放资源,与程序异常后进入catch忘记释放内存及多次释放同一块内存引起的内存泄漏
2.将值语义转为引用语义
智能指针的使用
本文介绍三个智能指针:unique_ptr、shared_ptr、weak_ptr。auto_ptr已经被C++11丢弃了。
shared_ptr
1.shared_ptr多个指针指向相同的对象,使用引用计数,每一次shared_ptr的拷贝指向相同的内存,每使用一次,内部引用计数加1,每析构一次,内部引用计数减1,直至减为0,自动删除指向的堆内存,shared_ptr内部的引用计数是线程安全的,但对象的读取需要加锁
2.智能指针是一个模板类,可以指定其类型,传入的指针使用构造函数初始化,也可使用make_shared函数初始化,不能把一个指针赋给智能指针,因为一个是类,一个是指针,如shared_ptr p=new int(1);错误
3.拷贝使得对象的引用计数加1,赋值使得原对象的引用计数减1,当计数为0时,自动删除指向的内存,后来指向的对象的引用计数加1,指向后来的对象。
4.缺陷为:循环引用,会导致内存泄漏问题,解决办法为使用弱引用的智能指针,即weak_ptr1、shared_ptr是只有c++11版本才能使用的。因此再编译或者再编写makefile的时候要注意一下。
2、shared_ptr unique_ptr 两者最大的不同在于它支持两个指针指向同一块内存。
3、shared_ptr支持delete []。c++17前
std::shared_ptr
都有一个严重的限制,那就是它并不支持动态数组,这个要注意;
#include <iostream>
#include <memory>
int main() {
{
int a = 10;
std::shared_ptr<int> ptra = std::make_shared<int>(a);
std::shared_ptr<int> ptra2(ptra); //copy
std::cout << ptra.use_count() << std::endl; //= 2
int b = 20;
int *pb = &a;
//std::shared_ptr<int> ptrb = pb; //error
std::shared_ptr<int> ptrb = std::make_shared<int>(b);
ptra2 = ptrb; //assign -1
pb = ptrb.get(); //获取原始指针
std::cout << ptra.use_count() << std::endl; //= 1
std::cout << ptrb.use_count() << std::endl; //= 2
}
}
unique_ptr
1.unique_ptr唯一拥有其所指对象,在同一时刻只能有一个unique_ptr指向给定对象(不允许拷贝,赋值操作),与原始指针不同的是,当异常发生时,动态资源得以释放。
2.unique_ptr本身的生命周期:从unique_ptr指针创建到离开作用域,离开作用域时,若其指向对象,所指对象被销毁(默认使用delete操作符)
3.unique_ptr指针与所指向对象的关系:创建智能指针使用构造函数初始化,使用reset重新指定,使用release释放所有权,通过移动语义转移所有权。
这里稍微说以下如何用unique_ptr进行相互赋值,这当中有三种情况,第一种情况是两个指针都是unique_ptr,第二个情况是我要把unique_ptr变成普通指针,第三种情况是我要把普通指针变成unique_ptr。我们举个例子
unique_ptr <AutoPtr> autoPtrFirst(new AutoPtr(1));
unique_ptr <AutoPtr> autoPtrSecond(new AutoPtr(2));
AutoPtr *p = NULL;
好,我们针对以上三种情况进行讨论。
第一种情况:假如我们要把autoPtrSecond指向autoPtrFirst那么我们应该怎么做呢?我们可以这样写。autoPtrSecond = std::move(autoPtrFirst),即把First指针移动走,只留下Second指针。
第二种情况:如果我要把unique_ptr指针变成普通指针应该怎么做呢?我们可以这样写。p = autoPtrFirst.release(),这样我们就可以把autoPtrFirst移动走,然后让p指向原来的地址空间了。第三种情况:如果我们要把普通指针变成unique_ptr指针应该怎么做呢?我们可以这样写。autoPtrFirst.reset(p),这样我们就可以将autoPtrFirst指向p了。
支持动态数组:
std::unique_ptr<int[]> up1(new int[10]());
建议:使用 vector<T> 容器而不是 unique_ptr<T[]>,因为该容器类型比智能指针强大得多,也灵活得多。
#include <iostream>
#include <memory>
int main() {
{
std::unique_ptr<int> uptr(new int(10)); //绑定动态对象
//std::unique_ptr<int> uptr2 = uptr; //不能賦值
//std::unique_ptr<int> uptr2(uptr); //不能拷贝
std::unique_ptr<int> uptr2 = std::move(uptr); //转换所有权
uptr2.release(); //释放所有权
}
//超过uptr的作用域,內存释放
}
weak_ptr
weak_ptr是配合shared_ptr出现的,不具有普通指针的行为,没有重载operator*和->最大作用在于协助shared_ptr观测资源的使用情况,可以从一个shared_ptr或一个weak_ptr对象构造,使用其成员函数use_count()获得观测资源的引用计数,expired()功能等价于use_count()==0标识被观测的资源已经不存在。
weak_ptr可以使用lock()获得一个新的shared_ptr对象,从而操作资源,但expired()==true时,lock函数返回一个存储空指针的shared_ptr对象
#include <iostream>
#include <memory>
int main() {
{
std::shared_ptr<int> sh_ptr = std::make_shared<int>(10);
std::cout << sh_ptr.use_count() << std::endl;
std::weak_ptr<int> wp(sh_ptr);
std::cout << wp.use_count() << std::endl;
if(!wp.expired()){
std::shared_ptr<int> sh_ptr2 = wp.lock(); //get another shared_ptr
*sh_ptr = 100;
std::cout << wp.use_count() << std::endl;
}
}
//delete memory
}
weak_ptr是一种不控制所指向对象生存期的智能指针,它指向由一个shared_ptr管理的对象。将一个weak_ptr绑定到一个shared_ptr不会改变 shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁,对象就会被释放。即使有weak_ptr指向对象,对象也还是会被释放,因此,weak_ptr的名字抓住了这种智能指针“弱”共享对象的特点。
weak_ptr的出现是为了解决shared_ptr循环引用的。
class B;
class A {
public:
A() { std::cout << "A's constructor " << std::endl; }
~A() { std::cout << "A's disconstructor " << std::endl; }
std::shared_ptr<B> b;
};
class B {
public:
B() { std::cout << "B's constructor " << std::endl; }
~B() { std::cout << "B's disconstructor " << std::endl; }
std::shared_ptr<A> a;
};
int main()
{
std::shared_ptr<A> spa = std::make_shared<A>();
std::shared_ptr<B> spb = std::make_shared<B>();
spa->b = spb;
spb->a = spa;
std::cout << "sqa的强引用个数 " << spa.use_count() << std::endl;
std::cout << "sqb的强引用个数 " << spb.use_count() << std::endl;
return 0;
}
// 输出结果
A's constructor
B's constructor
sqa的强引用个数 2
sqb的强引用个数 2
从上可以看出,由于spa和spb的强引用计数永远大于等于1,所以A和B的析构函数不会被调用。
当我们创建一个weak_ptr时,要用一个shared_ptr来初始化它
auto p = make_shared<int>(10);
weak_ptr<int> wp(p);
std::cout << "p的强引用为 " << p.use_count() << std::endl; // 为1
wp和p指向相同的对象,由于是弱引用,创建wp不会改变p的引用计数;wp指向的对象可能被释放掉。
利用weak_ptr修改上面的循环引用。
class B;
class A {
public:
A() { std::cout << "A's constructor " << std::endl; }
~A() { std::cout << "A's disconstructor " << std::endl; }
std::shared_ptr<B> b;
};
class B {
public:
B() { std::cout << "B's constructor " << std::endl; }
~B() { std::cout << "B's disconstructor " << std::endl; }
std::weak_ptr<A> a;
};
int main()
{
std::shared_ptr<A> spa = std::make_shared<A>();
std::shared_ptr<B> spb = std::make_shared<B>();
spa->b = spb;
spb->a = spa;
std::cout << "sqa的强引用个数 " << spa.use_count() << std::endl;
std::cout << "sqb的强引用个数 " << spb.use_count() << std::endl;
return 0;
}
// 结果输出
A's constructor
B's constructor
sqa的强引用个数 1
sqb的强引用个数 2
A's disconstructor
B's disconstructor
可以看出spa的强引用变为1,然后其释放后 spb 为1 。所以weak_ptr配合shared_ptr解决循环引用问题。
weak_ptr使用注意点
因为weak_ptr是一种弱引用,其指向shared_ptr,可能shared_ptr已经释放了。所以我们不能使用shared_ptr直接访问对象。先看下weak_ptr的用法:
weak_ptr<T> w //空weak_ptr可以指向类型为T的对象
weak_ptr<T> w(sp) //与shared_ptr sp指向相同对象的weak_ptr。T必须能转换为sp指向的S型
w = p //p可以是一个shared_ptr或一个weak_ptr。赋值后w与p共享对象
w.reset() //将W置为空
w.use_count() //与w共享对象的shared ptr的数量
w.expired() //若 w.use_count()为0,返回true,否贝y返回 false
w.lock() //如果expired为true,返回一个空shared ptr:否则返回一个 指向w的对象的shared_ptr
所以我们用weak访问对象时,可以通过lock来判断
auto p = make_shared<int>(10);
weak_ptr<int> wp(p);
if (std::shared_ptr<int> np = wp.lock()) { // 如果np不为空则条件成立
// np和p共享对象
}
智能指针的实现
智能指针类将一个计数器与类指向的对象相关联,引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时,初始化指针并将引用计数置为1;当对象作为另一对象的副本而创建时,拷贝构造函数拷贝指针并增加与之相应的引用计数;对一个对象进行赋值时,赋值操作符减少左操作数所指对象的引用计数(如果引用计数为减至0,则删除对象),并增加右操作数所指对象的引用计数;调用析构函数时,构造函数减少引用计数(如果引用计数减至0,则删除基础对象)。智能指针就是模拟指针动作的类。所有的智能指针都会重载 -> 和 * 操作符。智能指针还有许多其他功能,比较有用的是自动销毁。这主要是利用栈对象的有限作用域以及临时对象(有限作用域实现)析构函数释放内存。
#include <iostream>
#include <memory>
template<typename T>
class SmartPointer {
private:
T* _ptr;
size_t* _count;
public:
SmartPointer(T* ptr = nullptr) :
_ptr(ptr) {
if (_ptr) {
_count = new size_t(1);
} else {
_count = new size_t(0);
}
}
SmartPointer(const SmartPointer& ptr) {
if (this != &ptr) {
this->_ptr = ptr._ptr;
this->_count = ptr._count;
(*this->_count)++;
}
}
SmartPointer& operator=(const SmartPointer& ptr) {
if (this->_ptr == ptr._ptr) {
return *this;
}
if (this->_ptr) {
(*this->_count)--;
if (this->_count == 0) {
delete this->_ptr;
delete this->_count;
}
}
this->_ptr = ptr._ptr;
this->_count = ptr._count;
(*this->_count)++;
return *this;
}
T& operator*() {
assert(this->_ptr == nullptr);
return *(this->_ptr);
}
T* operator->() {
assert(this->_ptr == nullptr);
return this->_ptr;
}
~SmartPointer() {
(*this->_count)--;
if (*this->_count == 0) {
delete this->_ptr;
delete this->_count;
}
}
size_t use_count(){
return *this->_count;
}
};
int main() {
{
SmartPointer<int> sp(new int(10));
SmartPointer<int> sp2(sp);
SmartPointer<int> sp3(new int(20));
sp2 = sp3;
std::cout << sp.use_count() << std::endl;
std::cout << sp3.use_count() << std::endl;
}
//delete operator
}
6 shared_ptr多线程
shared_ptr的引用计数本身是安全且无锁的,但对象的读写则不是,因为 shared_ptr 有两个数据成员,读写操作不能原子化。这部分请看陈硕大佬的博客:为什么多线程读写 shared_ptr 要加锁?