学步园

template<class T>

class StrongRefPtr{};

在此模版中必然会用到T中的函数或变量，模版要的是复用，这些函数或变量应该是class T 都有的函数和变量，因此，我们的这个模版应该是针对一个设计好了的类进行设计，且这个被设计好的类应该被广泛的派生出子类型用于实例化类模版。

模版与派生之间的区别

有着相同的行为，仅仅是类型的不同。为此去新建一个类是不值得的因此使用模版来复用代码。而我们的派生类与父类的行为只是表面上的相同，内部却是不一样的，如果都一样，就没有多态存在的必要了。比方说，鸟类是父类，有飞这个性质，而麻雀和凤凰派生自鸟类，当然都有飞这个行为，而飞的具体动作却是不一样的，并且可以在凤凰类上添加发光这个行为，而父类却是没有的，这是类模版无法产生的。说到底模版产生的是相同的行为，典型应用是算法模版。虽然实例化时传入的类型是不同的，但做的事情是一样的。派生的做的事情是不一样的。通常，传入的类型应该都派生自一个基类或者至少拥有类模版中用到的行为和属性，如下：

class Parent{};

class son : public Parent

{};

son是子类，显然会增加自己的东西和改变从父类派生来的函数的内容，但是，对于模版类来讲，父类子类都一样，干的事情一样，即使结果不一样。

纯属个人见解，欢迎批评指正。

例如：

#include <iostream>
using namespace std;
class Base
{
public:
    Base(){}
    ~Base(){}
protected:
    void incRefcount(){mRefCount++;}
    void desRefcount()
    {
        if(--mRefCount == 0)
            delete this;
    }
    int getRefcount() const
    {return mRefCount;}
private:
    int mRefCount;
};
template <class T>
class BasePtr
{
public:
    BasePtr(){m_ptr = NULL;}
    BasePtr(T* t){m_ptr = t;}
public:
    T* set(T* t)
       {
           if(m_ptr != NULL)
               delete m_ptr;
           m_ptr = t;
           return t;
    }
    T* getPtr()
    {return m_ptr;}
protected:
    void incRefcount()
    {
        if(m_ptr == NULL)
            return;
        m_ptr->incRefcount();
    }
    void decRefcount()
    {
        if(m_ptr == NULL)
            return;
        m_ptr->desRefcount();
    }
private:
    T* m_ptr;
};

class DerivedClass1 : public Base
{
public:
    DerivedClass1():Base(){diff = 0;}
    ~DerivedClass1(){}
public:
    int diff;
};
class DerivedClass2 : public Base
{
public:
    DerivedClass2():Base(){aree = 1;}
    ~DerivedClass2(){}
public:
    int aree;
};
typedef BasePtr<DerivedClass1> classOne;
typedef BasePtr<DerivedClass2> classTwo;
int main()
{
    classOne a;
    DerivedClass1 s;
    a.set(&s);
    classTwo b;
    DerivedClass2 y;
    b.set(&y);
    cout << a.getPtr()->diff<<endl;
    cout << b.getPtr()->aree <<endl;
    return 0;
}