//SPtr.h
#ifndef S_PTR_H
#define S_PTR_H
template <typename T0, typename T1 = unsigned int> class SPtr
{
template <typename T0, typename T1> friend class SPtr;
public:
SPtr(T0 * ptr = 0)
:ptr_(ptr), use_(new T1(1))
{}
SPtr(const SPtr & sPtr)
:ptr_(sPtr.ptr_), use_(sPtr.use_)
{++*use_;}
template <typename T0, typename T1>
SPtr(const SPtr<T0, T1> & sPtr)
:ptr_(sPtr.ptr_), use_(sPtr.use_)
{++*use_;}
SPtr & operator =(const SPtr & sPtr)
{
++*sPtr.use_;
RemRef();
ptr_ = sPtr.ptr_;
use_ = sPtr.use_;
return *this;
}
template <typename T0, typename T1>
SPtr & operator =(const SPtr<T0, T1> & sPtr)
{
++*sPtr.use_;
RemRef();
ptr_ = sPtr.ptr_;
use_ = sPtr.use_;
return *this;
}
T0 & operator *() const
{return *ptr_;}
T0 * operator ->() const
{return ptr_;}
~SPtr() throw()
{RemRef();}
private:
void RemRef() const
{
if(--*use_ == 0)
{
delete ptr_;
delete use_;
}
}
T0 * ptr_;
T1 * use_;
};
#endif
不要小瞧这段简单的C++代码,它不但实现了安全快速的垃圾回收功能,而且在默认转化方面有着不可小觑的优势。
//Main.cpp
#include "SPtr.h"
#include <iostream>
class A
{
public:
A(){std::cout << "A()" << std::endl;}
virtual ~A(){std::cout << "~A()" << std::endl;}
void Func0() const{std::cout << "void Func0() const" << std::endl;}
void Func1(){std::cout << "void Func1() const" << std::endl;}
};
class B : public A
{
public:
B(){std::cout << "B()" << std::endl;}
~B(){std::cout << "~B()" << std::endl;}
};
void Test()
{
SPtr<B> pB0 = new B();
SPtr<A> pA0 = new A();
//SPtr的优势0:像内置指针一样的默认转换
SPtr<A> pA1 = pB0; //指向派生类变量的指针初始化指向基类变量的指针
SPtr<const A> pA2 = pA0; //指向变量的指针初始化指向常量(或不可变变量)的指针
pA2 = pB0; //指向派生类变量的指针赋值指向基类常量(或不可变变量)的指针
//SPtr的优势1:像内置指针一样的使用方式
pA0->Func0();
pA1->Func1();
pA2->Func0();
//pA2->Func1(); //Error!
}
int main(int argc, char *argv[])
{
Test();
return 0;
}