原理
原理是用引用计数,每次调用构造函数,拷贝构造时引用计数加1,调用赋值运算符时引用计数也加1,但之前指向的对象的引用计数减1。当引用计数减少至0时才调用析构函数。具体地,该智能指针类里包含了两个指针,一个指向资源,一个计数,故大小为原始指针的两倍。
代码实现
template<typename T>
class mySharedPointer{
public:
mySharedPointer(T* p):count(new int(1)),_ptr(p){
cout << "call sharedPointer constructor..." << endl;
}
mySharedPointer(mySharedPointer<T>& other):count(&(++*other.count)),_ptr(other._ptr){
cout << "call sharedPointer copy constructor..." << endl;
}
T* operator->(){return _ptr;}
T& operator*(){return *_ptr;}
mySharedPointer<T>& operator=(mySharedPointer<T>& other){
cout << "call sharedPointer assignment operator..." << endl;
++*other.count;
if(this->_ptr&&0==--*this->count){
delete _ptr;
delete count;
}
this->_ptr = other._ptr;
this->count = other.count;
return *this;
}
~mySharedPointer(){
if(--*count==0){
delete _ptr;
delete count;
cout << "call sharedPointer destructor..." << endl;
}
}
int getRef(){return *count;}
private:
int* count;
T* _ptr;
};
class Person{
public:
Person(int v):value(v){
cout << "constructor " << value << "..."<< endl;
}
~Person(){
cout << "desctructor" << value << "..." << endl;
}
private:
int value;
};
int main(){
mySharedPointer<Person> p1(new Person(1));
mySharedPointer<Person> p2(new Person(2));
mySharedPointer<Person> p3 = p1;
p3 = p2;
cout << "Ref: " << p1.getRef() << " " << p2.getRef() << " " << p3.getRef() << endl;
return 0;
}
执行结果
constructor 1…
call sharedPointer constructor…
constructor 2…
call sharedPointer constructor…
call sharedPointer copy constructor…
call sharedPointer assignment operator…
Ref: 1 2 2
desctructor2…
call sharedPointer destructor…
desctructor1…
call sharedPointer destructor…
参考:
https://www.cnblogs.com/runnyu/p/5822304.html
https://www.cnblogs.com/jiayayao/archive/2016/12/03/6128877.html