感谢你的问答，不过，第一种方式是动态绑定吗？因为没有虚函数，所以在编译期就能确定了，不是吗？

@didigene: 看错了，第一种方式没法实现多态，动态绑定和静态绑定都是针对多态的。因此第一种方式和后面两种方式不在同一个比较基线上。

你好，我想知道第一种方式为什么不能替代第三种，有什么例子能说明第三种方式要优于第一种吗，非常感谢！

@didigene: 因为第一种方式实现不了多态。关于如何使用模板编程，你可以自学下，会发现很多精妙之处。第三种方式还有个优于第二种方式的方面：类型安全。我用WTL中一种最常的用法来演示（只为了说明问题，不是完整实现）：

template <class T>
class CDoubleBufferImpl

{

public:

   void DoPaint(CDCHandle /*dc*/){ // 派生类实现此方法}

   LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)

   {

      T* pT = static_cast<T*>(this);

      pT->DoPaint();  // 调用派生类的 DoPaint 方法

    }

  
};

@Launcher: 感谢您的及时回复，只就您给的这个例子而言，如果把模板去掉：

class CDoubleBufferImpl
{
public:
        void DoPaint(CDCHandle dc) {} //派生类重定义
        LRESULT OnPaint(UINT uMsg, ...) {
                DoPaint();  //调用被派生类覆盖的DoPaint()
        }
};

我想比较一下这两种方法。我写的的确不能用父类的指针或引用实现多态。但即使用模板实现这个功能，父类的类型必须含有派生类的类型，这样的多态的意义在哪，如

CDoubleBufferImpl<MyCDoubleBufferImpl>* myImpl = new MyCDoubleBufferImpl;

myImpl->OnPaint(...);

与其这样写，为何不直接写成

MyCDoubleBufferImpl* myImpl = new MyCDoubleBufferImpl;
myImpl->OnPaint(...);

我想CRTP的优势应该不在这里，您有提到提到类型安全，能否详细说明一下？

我后来查了一下，发现CRTP的确有非模板无法实现的功能：一个是在父类中写一个方法，其中涉及子类的拷贝；另一个是在父类中定义一个静态变量，并限制这个静态变量只在同一个派生类的对象之间共享。

例1：

template <typename Derived>
class Base
{
public:
    Derived* CopyMyself() {
        // 调用派生类Derived的拷贝构造函数
        return new Derived(static_cast<Derived&>(*this));
    }

    // 与另一个Derived对象交换
    void Swap(Derived& drv) {
        Derived temp = drv;
        drv = static_cast<Derived&>(*this);
        static_cast<Derived&>(*this) = temp;
    }
};

如果不用模板，这两个函数必须在每一个派生类中都写一遍。

例2. 统计实例化对象的个数

template <typename Derived>
class Countable
{
protected:
    Countable() {
        ++Countable<Derived>::count_;
    }

    Countable(const Countable<Derived>&) {
        ++Countable<Derived>::count_;
    }

    ~Countable() {
        --Countable<Derived>::count_;
    }

public:
    static int GetCount()  {
        return Countable<Derived>::count_;
    }

private:
    static int count_;
}

template <typename Derived>
int Countable<Derived>::count_ = 0;

(漏了个分号，不改了)

这是我知道的CRTP的两种用法，如果您还能想到别的可以告诉我。

谢谢！

@Launcher: 今上午我回复了你上面的内容，谈了我的几点想法，想让你看看的，但回复的内容不见了，很奇怪。

@didigene: 如果把模板参数去掉，你就无法实现多态，也就是是说基类的OnPaint不会调用派生类的DoPaint方法。那么你每个派生类都要自己重新去写OnPaint方法，而我们在OnPaint方法中需要将派生类重复的代码提炼到基类（这里的示例是为每个派生的窗体类实现Double-Buffer）。

类设计的一个重要原则是消除重复代码，达到代码复用。

请你在理解模板的时候，时刻和面向对象的设计原则结合起来。

类型安全的知识请自行阅读相关资料。

请多动手写代码，多看看优秀的代码，要理解为什么这样，而不是那样的问题的最好方式就是在实际的工作中去运用，然后维护一段时间，你就能对优秀代码有深刻的体会了。

@Launcher: 为什么是：

CDoubleBufferImpl<MyCDoubleBufferImpl>* myImpl = new MyCDoubleBufferImpl;

myImpl->OnPaint(...);

而不是：

MyCDoubleBufferImpl* myImpl = new MyCDoubleBufferImpl;
myImpl->OnPaint(...);

只能说这样疑问很初级，说明你还没学会怎么使用模板，实际上我们是这样来使用的：

template<class T>

class MyContorlImpl : CDoubleBufferImpl<MyContorlImpl>

{

    void DoPaint(CDCHandle dc){// MyControl 的绘制代码}

};

class MyControl : MyContorlImpl<MyControl>

{
};

MyControl ctl;

ctl.OnPaint();

事实上 MyControlImpl 还会继承多个模板类，也不会有OnPaint的显示调用（通过MESSAGE_MAP映射），我这里做了简化，具体的代码请参阅WTL源码。

如果你的需求足够简单，上面的代码会显得冗余，或者称为过度设计，但从整个WTL的体系结构来看，这样的设计提供了很好的可扩展性，可维护性(估计你没维护过代码，所以对这点也没有体会，通常来说就是设计规范，一致的代码结构能够减轻维护者对代码的理解负担)。

所以请你先理解了面向对象的设计原则后，再研究模板。

@Launcher: 非常感谢你！你的解释和用例都很详细，虽然我还有疑惑，但从中我多少能够感觉到运用模板的意图。我了解面向对象程序设计，但之前不用模板，或者只是很初级的用法。我也知道第一种方式的能力是非常有限的，但也不知道CRTP的能力究竟在哪，所以会拿来比。正如你说，关键是我不知道实际当中这些模式是怎么被用的，所以很疑惑地提出比较奇怪的问题。今后我会去多读与模板相关的源码，有问题还得向你请教！多谢！

@didigene: 回答你“不知道CRTP的能力究竟在哪”的最好方式，仍然是实践，请用你自己的方式实现一次WTL的如下类：CWindowImpl,CWindow,CDoubleBuffer,要求，别人使用你的基类能够用来实现自己的控件，比如CStatic,CEdit,CButton等基本控件。

经实践证明，在UI库的设计中，只有两种技术可用，一是虚函数（MFC），另一种就是模板（ATL/WTL），前者比后者语义简单，后者比前者性能更好，同时具备静态类型检查功能，那么在使用模板的时候，CRTP完美的解决了在父类中调用派生类方法的问题（因此，你不要拿CRTP来和非模板技术比较，而是要理解CRTP是运用模板技术的一种固定模式，我们讨论模板中的CRTP，等同于讨论设计模式中的抽象工厂（或适配器、组合、媒介等））。