<一>智能指针基础

代码1

int main(){

   //裸指针,手动开辟,需要自己释放,如果忘记了或者因为

   //程序逻辑导致p没有释放,那么就会导致内存泄漏

   int *p=new int(10);

   if(***){

     retur -1;

   }

   delete p;

   return 0;

}

有没有什么办法帮我们管理指针,确保资源释放?

智能指针

利用栈上的对象出作用域时自动析构的特征,来做到资源的自动释放

问题:是否可以在堆上创建裸指针?语法上没有问题,但是我们正式希望

栈上对象出作用域能自动析构的特征来达到自动管理指针的目的,如果

将智能指针创建在堆上,那又和原来的裸指针使用遇到的问题是一样的了

需要手动delete

代码2

#include <iostream>

using namespace std;

template<typename T>

class MySmartPtr1 {

public:

     MySmartPtr1(T * ptr=nullptr) : _mptr(ptr) {  }

	 ~MySmartPtr1() {

		 delete _mptr;

		 _mptr = nullptr;

	 }

	 T & operator*() { return *_mptr; }//返回的 是 & ， 需要修改值

	 T * operator->() { return _mptr; }

private:

	T * _mptr;

};

int main() {

	MySmartPtr1<int> ptr(new int(10));

	*ptr= 200;

	return 0;

}

代码2的问题

int main() {

	MySmartPtr1<int> ptr(new int(10));

       //使用ptr 拷贝构造ptr2，默认的拷贝构造方式是值拷贝,所以底层

       //_mptr指针 指向的是同一块内存,那么ptr2 和ptr析构的时候就会有问题了，两次析构同一片内存

        MySmartPtr1<int> ptr2(ptr);

	*mptr = 200;

	return 0;

}

如何解决呢?

1:不带引用计数的智能指针

auto_ptr C++库提供

C++11 新标准

scoped_ptr

unique_ptr

代码关于 auto_ptr

int main() {

	auto_ptr<int> ptr1(new int(100));

	auto_ptr<int> ptr2(ptr1);

	*ptr2 = 200;

        cout<<*ptr1<<endl;//执行报错,原因见下图

	return 0;

}

现在不推荐使用auto_ptr

容器中推荐用auto_ptr吗？ vector<auto_ptr> v1; v2(v1); 容器的拷贝构造和容器的赋值容易引起容器元素的拷贝构造和赋值,而auto_ptr的拷贝构造会将原来管理的底层资源(指针)置空

代码关于 scoped_ptr

int main() {

        scope_ptr的处理方式

        scope_ptr<int>(const scope_ptr<int> & src)=delete;//通过直接和谐掉这两个方法

        scope_ptr<int> & operator=(const scope_ptr<int> & src))=delete;//通过直接和谐掉这两个方法

        return 0;

}

所以scoped_ptr使用的也很少

代码关于 unique_ptr

int main() {

        unique_ptr的处理方式

        unique_ptr<int>(const unique_ptr<int> & src)=delete;//通过直接和谐掉这两个方法

        unique_ptr<int> & operator=(const unique_ptr<int> & src))=delete;//通过直接和谐掉这两个方法

        unique_ptr<int> ptr1(new int(100));

	unique_ptr<int> ptr2(ptr1);//编译报错,尝试使用已经删除的函数, 要改成如下！！！

        unique_ptr<int> ptr1(new int(100));

        unique_ptr<int> ptr2(std::move(ptr1));//编译OK，为什么可以呢？因为unique_ptr提供了右值引用的拷贝构造和右值引用的赋值函数,如下

        unique_ptr<int>(const unique_ptr<int> && src){};

        unique_ptr<int> & operator=(const unique_ptr<int> && src)){};

        return 0;

}

//推荐使用

2:带引用计数的智能指针(share_ptr,weak_ptr)

带引用计数的好处:多个智能指针可以管理同一个资源

带引用计数:给每一个对象资源,匹配一个引用计数,

智能指针引用一个资源的时候,给这个资源引用计数加1

当这个智能指针出作用域不再使用资源的时候,给这个资源引用计数-1，当引用计数不为0的时候,还不能析构这个资源,

当引用计数为0的时候,说明已经没有外部资源使用这个资源了,那么就可以析构这个资源了

代码3 简单实现share_ptr

#include <iostream>

using namespace std;

template<typename T>

class RefCount {

public:

	RefCount(T * pSrc = nullptr, int refCount = 0):_pSrc(pSrc),_refCount(refCount) {

	}

	void addCount() { this->_refCount++; }

	void deleltCount() { --this->_refCount; }

	int  refCount() { return this->_refCount; }

private:

	T * _pSrc;

	int _refCount = 0;

};

template<typename T>

class MySmartPtr2 {

public:

	//新创建的智能指针,默认计数器为1

	MySmartPtr2<T> (T * mptr=nullptr): _mptr(mptr){

		_pRef = new RefCount<T>(_mptr,1);

	}

	//拷贝构造

	MySmartPtr2<T>(const MySmartPtr2<T> & _rval) {

		//两个智能指针指向相同的资源

		this->_mptr = _rval._mptr;

		this->_pRef = _rval._pRef;

		this->_pRef->addCount();

	}

	//赋值重载

	MySmartPtr2<T> & operator=(const MySmartPtr2<T> & _rval) {

		if (this == &_rval) { retur *this; }

		else {

			this->_pRef->deleltCount();

			int currentCount = this->_pRef->refCount();

			if (currentCount == 0) {

				delete this->_mptr;//销毁指向的资源

				this->_mptr = nullptr;

				delete _pRef;

				_rPef = nullptr;

			}

			this->_pRef = _rval._pRef;

			this->_mptr = _rval._mptr;

			this->_pRef->addCount();

			return *this;

		}

	}

	~MySmartPtr2<T>() {

		this->_pRef->deleltCount();

		int currentCount = this->_pRef->refCount();

		if (currentCount == 0) {

			delete this->_mptr;//销毁指向的资源

			this->_mptr = nullptr;

			delete _pRef;

			_pRef = nullptr;

		}

	}

	int getRefCount() { return this->_pRef->refCount(); }

private:

	T * _mptr;

	RefCount<T> * _pRef;

};

int main() {

	MySmartPtr2<int> ms1(new int(100)) ;

	{

		MySmartPtr2<int> ms2(ms1);

		cout << "RefCount=" << ms1.getRefCount() << endl;

		MySmartPtr2<int> ms3(ms1);

		cout << "RefCount=" << ms1.getRefCount() << endl;

	}

	cout << "RefCount=" << ms1.getRefCount() << endl;

	system("pause");

	return 0;

}

share_ptr: 强智能指针,可以改变资源的引用计数

weak_ptr: 弱智能指针,不会改变资源的引用计数

强智能指针:循环引用(交叉引用)是什么问题?什么结果?怎么解决?

交叉引用代码

class A{

pubic:

    A(){cout<<"A()"<<endl;}

    ~A(){cou<<"~A()"<<endl;}

    share_ptr<B> _ptrb;

}

class B{

pubic:

    B(){cout<<"B()"<<endl;}

    ~B(){cou<<"~B()"<<endl;}

    share_ptr<A> _ptrb;

}

int main(){

     share_ptr<A> pa(new A());

     share_ptr<B> pb(new B());

     pa->_ptrb=pb;

     pb->_ptra=pa;

     cout<<pa.use_count()<<endl;// 2

     cout<<pb.use_count()<<endl;// 2

}

上面代码造成new出来的资源无法释放!!资源泄漏问题

解决:

定义对象的时候,用强智能指针,引用对象的地方用弱智能指针

class A{

pubic:

    A(){cout<<"A()"<<endl;}

    ~A(){cou<<"~A()"<<endl;}

    void testA(){

        cout<<"A testA() Function"<<endl;

    }

    weak_ptr<B> _ptrb;

}

class B{

pubic:

    B(){cout<<"B()"<<endl;}

    ~B(){cou<<"~B()"<<endl;}

    void function(){

         share_ptr<A> _tp=_ptrb.lock();//提升方法

         if(_tp!=nullptr){

             _tp->testA();

         }

    }

    weak_ptr<A> _ptrb; //weak_ptr 弱智能指针,不会改变引用计数

}

int main(){

     share_ptr<A> pa(new A());

     share_ptr<B> pb(new B());

     pa->_ptrb=pb;

     pb->_ptra=pa;

     pb.function();

     cout<<pa.use_count()<<endl;// 2

     cout<<pb.use_count()<<endl;// 2

}

share_ptr 和 weak_ptr 是线程安全的.

巴特西

<一>智能指针基础

最新文章

热门文章