手写智能指针（类）

基础知识：

智能指针的设计与实现:

1.智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。

2.每次创建类的新对象时，初始化指针并将引用计数置为1；

3/当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；

4.对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；

5.调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。

6.所有的智能指针都会重载 -> 和 * 操作符。智能指针还有许多其他功能，比较有用的是自动销毁。

 

 

 

#include <iostream>

#include <memory>

 

using namespace std;

 

template <typename T>

class smartpointer{

public:

//构造函数

smartpointer(T* ptr = NULL) :_ptr(ptr)

{

if (_ptr)//如果实例化了，就建立计数器

{

_count = new size_t(1);

}

else{

_count = new size_t(0);

}

}

 

//拷贝构造函数（相同的话就不拷贝）

smartpointer(const smartpointer& smp)

{

if (this == &smp)

return;

else{

this->_ptr = smp._ptr;

this->_count = smp._count;

(*this->_count)++;

}

}

 

//赋值函数(左值减少，右值增加)  //特别说明：不是构造函数

smartpointer& operator = (const smartpointer& smp)

{

if (this->_ptr == smp._ptr)

{

return *this;

}

 

if (this->_ptr)

{

(*this->_count)--;

if ((*this->_count) == 0)

{

delete this->_ptr;

delete this->_count;

}

}

 

this->_ptr = smp._ptr;

this->_count = smp._count;

(*this->_count)++;

return *this;

}

 

//重载->和*

T& operator -> ()

{

assert(this->_ptr == NULL);

return (*this->_ptr);

}

 

T* operator * ()

{

assert(this->_ptr == NULL);

return this->_ptr;

}

 

size_t use_count()

{

return *this->_count;

}

 

//析构函数

~smartpointer()

{

if (*this->_count == 0)

{

delete this->_ptr;

delete this->_count;

cout << "释放" << endl;

}

else{

(*this->_count)--;

if (*this->_count == 0)

{

delete this->_ptr;

delete this->_count;

cout << "释放" << endl;

}

}

}

private:

T* _ptr;

size_t* _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;

 

//SmartPointer<int> sp(NULL);

//std::cout << sp.use_count() << std::endl;

}

 

system("pause");

return 0;

}