智能指针:
//不在智能指针中研究const
1.为什么需要智能指针?
裸指针:int *ip=NULL;//无法判断指的是一个对象还是一组对象
直接定义的指针是裸指针
class shape{};
std::vector<shape*>shape;
int *ip;//野指针
Object*op=NULL;//空指针
Destory(Object*ip){delete ip; }//失效指针,悬空指针
2.智能指针分类
unique_ptr拥有独有对象所有权
shared_ptr拥有共享对象所有权
weak_ptrstd::shared_ptr所管理对象的弱作用
auto_ptr严格对象所有权
3.c++11中弃用,c++17中移除
/auto_ptr 不使用的原因: //拷贝构造函数 意义不明确
//浅拷贝:会对一个对象造成析构两次
//my_auto_ptr(cosnt my_auto_ptr &op):Owns(op.Owns),Ptr(op.Ptr){}
// //my_auto_ptr(cosnt my_auto_ptr &op):Owns(op.Owns),Ptr(op.release()){} //
STL vector,list中不用auto_ptr
SRL boost
4.auto_ptr源码
template <class _Ty>
class my_auto_ptr
{
private:
bool _Owns;
_Ty* Ptr;
public:
explicit my_auto_ptr(_Ty* p = NULL) :_Owns(p != NULL), _Ptr(p) {}
~my_auto_ptr()
{
if (_Owns) { delete _Ptr; }
_Owns = false;
_Ptr = NULL;
}
_Ty* get()const { return _Ptr; }
_Ty& operator*()const
{
return *(get());
}
_Ty* operator->()const
{
return &**this;//return get();
}
void reset(_Ty* p)
{
if (_Owns)
{
delete _Ptr;
}
_Ptr = p;
}
};
//辅助类--default——delete
//删除器
template<class _Ty>
class MyDeletor
{
public:
MyDeletor(){}
void operator()(_Ty* ptr) const
{
if(ptr!=nullptr)
delete ptr;
}
};
template<class _Ty>
class MyDeletor<_Ty[]>
{
public:
MyDeletor() = default;//明确的告知有构造函数
void operator()(_Ty* p tr) const
{
if (ptr != nullptr)
delete[] ptr;
}
};
//class unique_ptr
template<class _Ty,class _Dx=MyDeletor<_Ty>>
class my_unique_ptr
{
public:
//old
//typedef _Ty* pointer;
//typedef _Ty element_type;
//typedef _Dx delete_type;
//
//c11 new,对已有的类型进行重命名
using pointer = _Ty*;
using element_type = _Ty;
using delete_type = _Dx;//删除器
private:
_Ty* _Ptr;//指针
_Dx _myDeletor;//删除器
public:
my_unique_ptr(const my_unique_ptr&) = delete;
my_unique_ptr& operator=(const my_unique_ptr&) = delete;
my_unique_ptr(my_unique_ptr&& _Y)
{
_Ptr = _Y._Ptr;
_Y._Ptr = nullptr;
}
my_unique_ptr& operator=(my_unique_ptr&& _Y)
{
if (this == &_Y) return *this;
reset(_Y.release());
//if(_Ptr!=nullptr){_myDeletor(_Ptr):}
//_Ptr=_Y._Ptr;
//_Y._Ptr=nullptr;
return *this;
}
const _Dx & get_deleter()const
{
return myDeletor;
}
_Dx& get_deleter()
{
return myDeletor;
}
_Ty& operator*()const
{
return *_Ptr;
}
pointer operator->()const
{
return &**this;//_Ptr;
}
pointer get()const
{
return _Ptr;
}
//强转成bool类型
operator bool()const
{
return _Ptr != nullptr;
}
my_unique_ptr(pointer _P=nullptr):_Ptr(_P){}
~my_unique_ptr()
{
if (_Ptr != nullptr)
{
_myDeletor(_Ptr);//调动对象的仿函数,——myDeletor对象的仿函数
_Ptr = nullptr;
}
}
pointer release()
{
_Ty* old = _Ptr;
_Ptr = nullptr;
return old;
}
void reset(pointer _P = nullptr)
{
pointer old = _Ptr;
_Ptr = _P;
if (old != nullptr)
{
_myDeletor(old);
get_deleter()(old);
}
}
void swap(my_unique_ptr _Y)
{
std::swap(_Ptr, _Y._Ptr);
std::swap(_myDeletor, _Y.myDeletor);
}
};
5.注意
作为函数的参数按值传递一定要避免
auto_ptr
不能指向数组
不能共享所有权
不能通过复制操作来初始化
不能放入容器中使用
不能作为容器成员