首先要知道智能指针是用来解决什么问题的,首先我们先看下面这段代码
void Func(int *p)
{
int *sp = new int;
if (p == NULL)
{
throw std::exception("p is NULL");
}
delete sp;
}
这个函数有一个很大的问题,如果传入的参数p为空,遇到 if 语句就命中之后就会抛出异常,程序中断。那么指针sp指向开辟的内存没有释放,导致内存泄漏。有什么方法可以来解决这个问题?
栈:系统开辟内存,系统释放;堆:手动开辟内存,手动释放。那么如果能对堆上空间实现用户分配、系统自行回收的机制,就不用担心内存泄露的问题了。
智能指针的思想:定义一个类来封装资源的分配和释放,在构造函数完成资源的分配和初始化,在析构函数中完成资源的清理和释放,可以保证资源的正确使用和释放。(资源指的是堆上资源)
看下面这段代码:
#include<iostream>
template <typename T>
class Smart_ptr
{
public:
Smart_ptr(T *ptr) :mptr(ptr)//构造函数
{}
~Smart_ptr()//析构函数
{
delete mptr;
mptr = NULL;
}
T& operator*()//*运算符重载
{
return *mptr;
}
T* operator->()//->运算符重载
{
return mptr;
}
private:
T *mptr;
};
int main()
{
Smart_ptr<int>sp1(new int);
*sp1 = 20;
Smart_ptr<int>sp2 = sp1;
}
Smart_ptr<int>sp2 = sp1;这句代码会释放同一块内存两次,导致程序出错。
这里介绍四个智能指针auto_ptr
1、auto_ptr(已经被摒弃)
实现一:不带标记的auto_ptr(所有权唯一)
#include<iostream>
template <typename T>
class Smart_ptr
{
public:
Smart_ptr(T *ptr) :mptr(ptr)
{}
~Smart_ptr()
{
delete mptr;
mptr = NULL;
}
Smart_ptr(const Smart_ptr<T>& rhs)//拷贝构造函数
{
mptr = rhs.mptr;
rhs.Release();//将旧的指针置为NULL
}
Smart_Ptr<T>& operator=(const Smart_Ptr<T>& rhs)//赋值运算符重载
{
if (this != &rhs)
{
delete mptr;
mptr = rhs.mptr;
rhs.Release();//将旧的指针置为NULL
}
return *this;
}
T& operator*()
{
return *mptr;
}
T* operator->()
{
return mptr;
}
private:
void Release()const
{
(T*)mptr = NULL;
}
T *mptr;
};
int main()
{
Smart_ptr<int>sp1(new int);
Smart_ptr<int>sp2 = sp1;
*sp1 = 20;
}
问题:*sp1 = 20; sp1指针指向已经为NULL,对其解引用访问了保留区的数据,程序出错。
实现二:带有标记的auto_ptr(释放权唯一,管理权不唯一),即可以多个auto_ptr管理同一片内存,但是只能有一个指针释放该片内存。怎么确定是哪个指针能释放呢?在成员变量中加入一个标志变量flag,flag为true则有释放权,flag为false则没有释放权。那么就牵扯释放权限转移的问题,概括来说就是旧智能指针拥有的权限,那么新智能指针也拥有。旧智能指针没有的权限,那么新智能指针也没有。
这个功能的实现:new flag = old flag; old flag = false;
#include<iostream>
template<typename T>
class SmartPtr
{
public:
SmartPtr(T* ptr) :mptr(ptr), flag(true)
{}
SmartPtr(const SmartPtr<T>& rhs) :mptr(rhs.mptr)
{
flag = rhs.flag;
rhs.flag = false;
}
SmartPtr<T>& operator = (const SmartPtr<T>& rhs)
{
if (this != &rhs)
{
this->~SmartPtr();
mptr = rhs.mptr;
flag = rhs.flag;
rhs.flag = false;
}
return *this;
}
~SmartPtr()
{
if (flag)
{
delete mptr;
}
mptr = NULL;
}
T& operator*()
{
return *mptr;
}
T* operator->()
{
return mptr;
}
private:
T* mptr;
mutable bool flag;//是否拥有释放权
};
void func(SmartPtr<int> sp)//true
{}
int main()
{
SmartPtr<int> sp1(new int);//false
SmartPtr<int> sp2 = sp1;//false
func(sp2);
*sp1 = 20;
return 0;
}
问题:根据管理权原则一,若旧智能指针有释放权,则新智能指针将释放权拿走,旧释放权false。那么如果这个新智能指针只是一个临时量,随着生存周期的到来也随之消失,那块被管理的内存岂不是莫名其妙就被释放了
void func(SmartPtr<int> sp)//true
{}
void test(SmartPtr<int> rhs)
{
std:: cout << *rhs << std::endl;
}
int main()
{
SmartPtr<int> p(new int(10));
SmartPtr<int> q(new int(20));
*p = 11;
*q = 22;
p = q;
SmartPtr<int> w = p;
test(w);//在传参的过程中,w的释放权发生转移
std::cout << "w" << *w << std::endl;//打印一个随机值
return 0;
}
2、Scope_ptr(管理权唯一,释放权唯一)
在auto_ptr中,因为设计的问题,导致在使用拷贝构造函数和 赋值运算符的可重载函数时,发生了访问 空指针、野指针的情况。为了规避这些情况,scoped_str在设计的时候就直接屏蔽了 拷贝构造函数 和 赋值运算符重载函数。
#include<iostream>
template<typename T>
class Scope_Ptr
{
public:
Scope_Ptr(T* ptr) :mptr(ptr){}
~Scope_Ptr()
{
delete mptr;
mptr = NULL;
}
T& operator*()
{
return *mptr;
}
T* operator->()
{
return mptr;
}
private:
Scope_Ptr(const Scope_Ptr<T>&);
Scope_Ptr<T>& operator=(const Scope_Ptr<T>&);
T* mptr;
};
int main()
{
int* p = new int;
Scope_Ptr<int> sp1(p);
Scope_Ptr<int> sp2(p);
return 0;
}
问题: scoped_ptr的原则也是“管理权唯一,释放权唯一”,因为屏蔽了 拷贝构造函数 和 赋值运算符重载函数,所以不可能通过这两种方式去 使得两个及以上的指针指向同一片内存,但是仍然避免不了人为的操作,如sp1和sp2;即初始化两个scope_ptr指向同一片内存,当其中一个指针释放了该内存,另一个再想去修改内存的内容的话程序就会崩溃
3、shared_ptr(管理权不唯一,释放权不唯一)
shared_ptr是基于“引用计数”实现的,多个shared_ptr可指向同一片内存,并且它们维护着共享的引用计数器——记录着指向同一片内存的shared_ptr对象的个数。当最后一个指向某一片内存的shared_ptr对象也销毁之后,会自动销毁掉该片内存。shared_ptr很好地解决了 多个智能指针指向一块内存块时, 析构时程序崩溃 的情况。
引用计数器:我们只需要一个 引用计数器对象,这个对象中就存储了所有关于内存引用的信息。
class Ref_Management
{
public:
void AddRef(void* mptr)//增加
{
std::vector<Node>::iterator it = find(mptr);//查找是否存在这个地址
if (it == vec.end())//引用计数表中不存在这个地址那么就增加一个
{
Node tmp(mptr, 1);
vec.push_back(tmp);
}
else
{
(*it).ref++;//存在,那么就加引用计数
}
}
void DelRef(void* mptr)//删除
{
std::vector<Node>::iterator fit = find(mptr);//查找是否存在这个地址
if (fit == vec.end())//如果找到最后都没有,那么就不存在抛出异常
{
throw std::exception("mptr is not exisit!");
}
else
{
if (GetRef(mptr) != 0)//判断该地址的引用计数
{
(*fit).ref--;//计数不为0就--
}
}
}
int GetRef(void* mptr)//获取
{
std::vector<Node>::iterator it = find(mptr);//查找是否存在这个地址
if (it == vec.end())//如果找到最后都没有,那么就不存在抛出异常
{
throw std::exception("ptr is not exsit!");
}
else
{
return (*it).ref;//找到返回引用计数
}
}
private:
class Node;
std::vector<Node>::iterator find(void* mptr)//使用迭代器查找
{
std::vector<Node>::iterator it = vec.begin();
for (it; it != vec.end(); it++)
{
if ((*it).addr == mptr)
{
break;
}
}
return it;
}
class Node//结点类型
{
public:
Node(void* pa = NULL, int r = 0) :addr(pa), ref(r){}//构造函数
public:
void* addr;//存放的地址
int ref;//引用计数
};
std::vector<Node> vec;
};
template<typename T>
class Shared_Ptr
{
public:
Shared_Ptr(T* ptr) :mptr(ptr)//构造函数
{
addref();
}
Shared_Ptr(const Shared_Ptr<T>& rhs) :mptr(rhs.mptr)//拷贝构造函数
{
addref();//增加引用计数
}
Shared_Ptr<T>& operator = (const Shared_Ptr<T>& rhs)//赋值运算符重载
{
if (this != &rhs)//防止自赋值
{
delref();//减引用计数
if (getref() == 0)//若引用计数为0,删除该指针
{
delete mptr;
}
mptr = rhs.mptr;
addref();
}
return *this;
}
~Shared_Ptr()
{
delref();//减引用计数
if (getref() == 0)//若引用计数为0,删除该指针
{
delete mptr;
}
mptr = NULL;
}
T& operator*()
{
return *mptr;
}
T* operator->()
{
return mptr;
}
private:
void addref()
{
rm.AddRef(mptr);
}
void delref()
{
rm.DelRef(mptr);
}
int getref()
{
return rm.GetRef(mptr);
}
T* mptr;
static Ref_Management rm;//引用计数器成员变量象
};
//静态成员变量类外初始化
template<typename T>
Ref_Management Shared_Ptr<T>::rm;
int main()
{
int* p = new int;
Shared_Ptr<int> sp1(p);
Shared_Ptr<int> sp2(p);
Shared_Ptr<int> sp3(p);
Shared_Ptr<int> sp4(new int);
return 0;
}
问题:虽然shared_ptr很好地解决了 “多个智能指针指向同一块内存时,析构时出错”的问题,可是同时也带来了新的问题。shared_ptr之间不能相互引用,否则管理的堆上内存块无法释放。