最简单最实用的C++ GC

//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;
}