引言
这是一个简单的实现shared_ptr的过程 因为是小练习的缘故 其中有些地方逻辑可能并不严密 希望大家指正
注意点
- 删除器因为shared_ptr的删除器是运行时绑定的 所以其类型应该是一个指针 所以我们需要一个函数指针 指向删除器
- 类的类型这是一个典型的类指针的类 有共用一个指针 其实使用智能指针存储是最优的 但是我们就是在实现智能指针嘛 所以就操作普通指针就好
using namespace std;
template <typename T> class Shared_ptr;
template<typename T,typename ... Args>
inline Shared_ptr<T>
make_Shared(Args&& ... args){
return Shared_ptr<int>(std::forward<Args>(args)...);
}
//这里只是简单的实现而已 其中并没有涉及到内存的分配 也就使得第一个参数有点浪费
template <typename T>
class Shared_ptr
{
private:
size_t *Ptr_Count;//引用计数
T* Mem_Ptr;//数据
void (*Del_Ptr)(T *); //删除器 用于在运行时绑定删除器
public:
decltype(Del_Ptr) Return_Del(){return Del_Ptr;}
//默认构造函数
Shared_ptr():Ptr_Count(nullptr),Mem_Ptr(nullptr),Del_Ptr(nullptr){}
//接收一个参数的构造函数(防止隐性转换)
explicit Shared_ptr(T *tmp_ptr) try:
Mem_Ptr(tmp_ptr),Ptr_Count(new size_t(1)),Del_Ptr(nullptr)
{} catch(const std::bad_alloc &err) {cout << "error in new\n";}
//不同类型转换
template<class type>
Shared_ptr(const Shared_ptr<type>& ptr) : Mem_Ptr(ptr->get()),Del_Ptr(ptr->Return_Del()),Ptr_Count(++(ptr->use_count())){}
//拷贝构造函数
Shared_ptr(Shared_ptr &tmp_ptr) noexcept(false){ //模板内部可简化为类名而不需要加类型
Mem_Ptr = tmp_ptr.Mem_Ptr;
Ptr_Count = tmp_ptr.Ptr_Count;
Del_Ptr = nullptr;
++*Ptr_Count;
}
//拷贝赋值运算符
void operator=(const Shared_ptr& tmp_ptr) & noexcept(false){
Shared_ptr(std::move(tmp_ptr));//并没有什么数据成员 所以效率并没有什么提升 练下手
}
//不同类型转换
template<class type>
void operator=(const Shared_ptr<type>& tmp_ptr) & noexcept(false){
Del_Ptr = tmp_ptr->Return_Del();
Ptr_Count = ++(tmp_ptr->use_count());
Mem_Ptr = tmp_ptr->get();
}
//移动构造函数
Shared_ptr(Shared_ptr && tmp_ptr) noexcept:
Mem_Ptr(tmp_ptr.Mem_Ptr),Ptr_Count(tmp_ptr.Ptr_Count),Del_Ptr(nullptr)
{++*Ptr_Count;}
//移动赋值运算符 //强制等号左边为左值
void operator=(Shared_ptr && ptr) & noexcept{
Shared_ptr(std::move(ptr));
}
//重载解引用运算符
T& operator*(){
return *Mem_Ptr;
}
T* operator->(){//至于为什么返回一个指针 因为Shared_ptr是一个类 类就应该返回一个成员
return Mem_Ptr;
}
T* get(){ //返回智能指针所保存的指针 操作危险
return Mem_Ptr;
}
size_t use_count(){
return *Ptr_Count;
}
bool unique(){
return *Ptr_Count == 1;
}
void swap(Shared_ptr &tmp_ptr){
//测试时使用原版本swap
//std::swap(*this,tmp_ptr); 这里概念还有问题 搞懂move原理以后再来
//交换指针效率更高
std::swap(Mem_Ptr,tmp_ptr.Mem_Ptr);
std::swap(Ptr_Count,tmp_ptr.Ptr_Count);
std::swap(Del_Ptr,tmp_ptr.Del_Ptr);
}
void reset(){ //当reset为空时 只是把reset的指针
if(*Ptr_Count == 1){
delete Mem_Ptr;
*Ptr_Count = 0; //防止析构时两次delete 用Ptr_count在析构时进行特判
}else {
Mem_Ptr = nullptr;
--*Ptr_Count;
}
}
void reset(T *tmp_ptr){
if(*Ptr_Count==1){ //本对象是唯一对象则会释放 //不唯一的话其他对象还需要这两个指针
Del_Ptr ? Del_Ptr(Mem_Ptr) : delete Mem_Ptr;
delete Ptr_Count;
}else{
--*Ptr_Count;
}
Mem_Ptr = tmp_ptr;
Ptr_Count = new size_t(1);//看起来很奇怪 仔细想想 如果count不为零的话其他智能指针还要使用
}
//接收一个指针和一个自定义的删除器 用于在析构时正确释放对象 默认为delete
void reset(T *tmp_ptr,void (*del_ptr)(T *)){
if(*Ptr_Count==1){
delete Mem_Ptr;
delete Ptr_Count;
}
--(*Ptr_Count);
Mem_Ptr = tmp_ptr;
Ptr_Count = new size_t(1);
Del_Ptr = del_ptr; //定义一个删除器
}
~Shared_ptr(){
try{
cout << "Commen complete the destructor.\n";
if(Mem_Ptr == nullptr && Ptr_Count == nullptr){ //防止默认构造出现对仅有delete 而无new
return;
}
if((*Ptr_Count) == 0){ //证明被reset了 特殊处理
delete Ptr_Count;
Ptr_Count = nullptr;
return;
}
--*Ptr_Count;
if(*Ptr_Count==0){
Del_Ptr ? Del_Ptr(Mem_Ptr) : delete Mem_Ptr;
delete Ptr_Count;
Ptr_Count = nullptr;
Mem_Ptr = nullptr;
}
}catch(...){
cout << "error in delete\n";
}
}
};
//一个测试用的聚合类
struct text{
int ans;
int weight;
};
void Del(text* tmp){//聚合类 text 的删除器
delete tmp;
cout << "Special complete the destructor.\n";
}
//demo
int main()
{
cout << "测试make_shared:\n";
Shared_ptr<int> str=make_Shared<int>(new int(5));
cout << ": " << *str << endl;
cout << "测试基本操作\n";
Shared_ptr<int> tmpa_ptr(new int(10));
cout << *tmpa_ptr << endl;
cout << tmpa_ptr.use_count() << endl;
Shared_ptr<int> tmpb_ptr(tmpa_ptr);
cout << *tmpb_ptr << endl;
cout << tmpb_ptr.use_count() << endl;
cout << "交换操作\n";
Shared_ptr<int> tmp_swap(new int(5));
cout << *tmpa_ptr << " " << *tmp_swap << endl;
tmpa_ptr.swap(tmp_swap);
cout << *tmpa_ptr << " " << *tmp_swap << endl;
cout << "测试三种参数的reset函数\n";
tmpa_ptr.reset();
cout << tmpa_ptr.use_count() << " " << tmpb_ptr.use_count() << endl;
shared_ptr<text> tmpc_ptr(new text({5,5}));
cout << (*tmpc_ptr).ans << " " << (*tmpc_ptr).weight << endl;
tmpc_ptr.reset(new text({10,10}));
cout << (*tmpc_ptr).ans << " " << (*tmpc_ptr).weight << endl;
tmpc_ptr.reset(new text({20,20}),Del);//shared_ptr删除器运行时绑定 所以使用指针存储删除器
cout << "测试get函数\n";
text *temp_text_ptr = tmpc_ptr.get(); //此函数小心使用 会返回智能指针所维护的指针域
cout << temp_text_ptr->ans << " " << temp_text_ptr->weight << endl;
cout << "开始析构\n";
return 0;
}
这是测试代码的输出
测试make_shared:
: 5
测试基本操作
10
1
10
2
交换操作
10 5
5 10
测试三种参数的reset函数
0 2
5 5
10 10
测试get函数
20 20
开始析构
Special complete the destructor.
Commen complete the destructor.
Commen complete the destructor.
Commen complete the destructor.
Commen complete the destructor.
在本篇博客中只是简单实现了make_shared 就像我们注释中所说的 这样的写法导致make_shard的第一个参数有些多余 但实际一定不是这样的 我们来看看make_shared的源码
template<typename _Tp, typename... _Args>
inline shared_ptr<_Tp>
make_shared(_Args&&... __args)
{
typedef typename std::remove_const<_Tp>::type _Tp_nc;
return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
}
我们可以看到第一个类型参数的存在是很有必要的 为了能够正确的分配内存 我们这个模板函数也应该由我们显式的提供类型
