假如你项目代码本身已经实现了很多的实体类，但并未采用接口，可以考虑以这种方式来实现接口化编程

struct ITest

{

    virtual void Test()=0;

};

class CTest

{

public:

    void Test() {}

};

class CTestProxy:public ITest

{

    void Test()

    {

        m_object.Test();

    }

protected:

    CTest m_object;

};

class TestObject

{

public:

    static void Demo()

    {

        ITest *pTest=new CTestProxy;

        pTest->Test();

    }

};

改过为模板化

template<class T, class I>

class CTestProxy:public I

{

    void Test()

    {

        m_object.Test();

    }

protected:

    T m_object;

};

再来看子类的实现

struct ISubTest:public ITest

{

    virtual void SubTest()=0;

};

class CSubTest:public CTest

{

public:

    void SubTest() {}

};

template<class T, class I>

class CSubTestProxy:public CTestProxy<T,I>

{

    void SubTest()

    {

        m_object.SubTest();

    }

};

此方法可以使用接口的形式重用原有实现代码

实体类与接口交互

struct ITest

{

    virtual void Test()=0;

    virtual ITest* GetProxy()=0;

    virtual void SetProxy(ITest* pTest)=0;

};

class CTest

{

public:

    CTest()

    {

        m_pTest=NULL;

    }

    void Test() {  }

    ITest* GetProxy() { return m_pTest; }

    void SetProxy(ITest* pTest) { m_pTest=pTest; }

    template<class T>

    T* Get()

    {

        ITest* pProxy=GetProxy();

        T* pT=dynamic_cast<T*>(pProxy);

        return pT;

    }

protected:

    ITest *m_pTest;

};

template<class T, class I>

class CTestProxy:public I

{

public:

    CTestProxy()

    {

        SetProxy(this);

    }

    void Test()

    {

        m_object.Test();

    }

    ITest* GetProxy() { return m_object.GetProxy(); }

    void SetProxy(ITest* pTest) { m_object.SetProxy(pTest); }

protected:

    T m_object;

};

添加一个指针便有了两边交互的能力

外部类继承:

需要将T m_object声明成为指针,该类并非为导出类,避免对外暴露实现