命名模板参数主要利用了C++继承中的一个规则，子类重定义，会隐藏基类中定义：
class DefaultPolicy1 { public: void print() { cout << "Policy 1" << endl; } }; class DefaultPolicy2 { public: void print() { cout << "Policy 2" << endl; } }; class DefaultPolicies { public: typedef DefaultPolicy1 P1; typedef DefaultPolicy2 P2; }; class DefaultPolicyArgs : virtual public DefaultPolicies { }; class Policy1_is : virtual public DefaultPolicies { public: typedef DefaultPolicy1 P2; }; class Policy2_is : virtual public DefaultPolicies { public: typedef DefaultPolicy2 P1; }; class PolicySelector : public DefaultPolicyArgs, public Policy2_is { }; int main() { PolicySelector::P1 p; p.print(); }上面例子中，Policy2_is重定义了P1，所以在PolicySelector中P1是DefaultPolicy2，结果输出：Policy 2。
DefaultPolicyArgs 类似乎是毫无意义的。如果删除DefaultPolicyArgs定义，PolicySelector定义改为：
class PolicySelector : public DefaultPolicies, public Policy2_is { };编译器会提示PolicySelector::P1不明确。
在上面例子中加入模板：
class DefaultPolicy1 { }; class DefaultPolicy2 { }; class DefaultPolicy3 { }; class DefaultPolicy4 { }; class SpecialPolicy { }; class DefaultPolicies { public: typedef DefaultPolicy1 P1; typedef DefaultPolicy2 P2; typedef DefaultPolicy3 P4; typedef DefaultPolicy3 P4; }; class DefaultPolicyArgs : virtual public DefaultPolicies { }; template <typename Policy> class Policy_is1 : virtual public DefaultPolicies { public: typedef Policy P1; }; template <typename Policy> class Policy_is2 : virtual public DefaultPolicies { public: typedef Policy P2; }; template <typename Policy> class Policy_is3 : virtual public DefaultPolicies { public: typedef Policy P3; }; template <typename Policy> class Policy_is4 : virtual public DefaultPolicies { public: typedef Policy P4; }; typename <typename Base, int D> class Discriminator : public Base { }; template <typename Setter1, typename Setter2, typename Setter3, typename Setter4> class PolicySelector : public Discriminator<Setter1, 1>, public Discriminator<Setter2, 2>, public Discriminator<Setter3, 3>, public Discriminator<Setter4, 4> { }; template <typename PolicySetter1 = DefaultPolicyArgs, typename PolicySetter2 = DefaultPolicyArgs, typename PolicySetter3 = DefaultPolicyArgs, typename PolicySetter4 = DefaultPolicyArgs> class BreadSlicer { public: typedef PolicySelector<PolicySetter1, PolicySetter2, PolicySetter3, PolicySetter4> Policies; };现在，使用BreadSlicer可以直接指定任何一个模板实参。如果定义一个BreadSlicer<Policy3_is >变量，那么PolicySelector相当于继承了DefaultPolicyArgs和Policy3_is，所以P3被重定义为SpecialPolicy类。模板Discriminator的引用是为了避免继承同一个类。
一般地，定义了一个EmptyClass这样的空类，其对象的大小也不会为0，也就是说需要分配内存。 但是C++规定，当空类作为基类时，只要不会与同一类型的另一个对象或者子对象分配在同一地址，就不需要为其分配内存。这就是空基类优化。
class Empty { }; class EmptyToo : public Empty { }; class EmptyThree : public EmptyToo { };在支持空基类优化的编译器环境中，上面代码中的3个类大小相同，但都不为0。也就是说EmptyToo和EmptyThree的基类都不占内存。C++环境中不存在真正意义上不占内存的类，空基类优化是针对空类作为基类时，在子类中是否需要分配内存的一个规则。
class NonEmpty : public Empty, public EmptyToo { };NonEmpty类中的基类Empty和EmptyToo都是占内存。否则，NonEmpty中的Empty直接基类和EmptyToo中的Empty间接基类地址就会重合，这违反了空基类优化规则。
下面是空基类优化的一个应用例子（更多情况可百度boost.compressed_pair）：
template <typename CustomClass> class Optimizable { private: CustomClass info; void* storage; };其中CustomClass一定是类类型，且可能为空，那么可以优化：
template <typename CustomClass> class Optimizable { private: BaseMemberPair<CustomClass, void*> info_and_storage; }; template <typename Base, typename Member> class BaseMemberPair : private Base { private: Member member; public: BaseMemberPair(Base const &b, Member const &m) : Base(b), member(m) {} Base const& first() const { return (Base const&)*this; } Base& first() { return (Base&)*this; } Member const& second() const { return this->member; } Member& second() { return this=>member; } };CRTP的主要特点是派生类将自身作为模板参数传给基类。
下面例子是一个数某个类对象个数的类模板。当需要计算某个类对象个数时，只要继承ObjectCount模板就可以，模板实参自然是类本身：
template <typename CountedType> class ObjectCounter { private: static size_t count; protected: ObjectCounter() { ++ObjectCounter<CountedType>::count; } ObjectCounter(ObjectCounter<CountedType> const&) { ++ObjectCounter<CountedType>::count; } ~ObjectCounter() { --ObjectCounter<CountedType>::count; } public: static size_t live() { return ObjectCounter<CountedType>::count; } }; template <typename CountedType> size ObjectCounter<CountedType>::count = 0;CRTP把类的功能提取出来，放到一个依赖于自身的模板类中实现，再继承模板类重新获取该功能。如果只有一个类需要，或者只有一个类通过该模式能够实现功能，那该模式是没有意义。CRTP的本质是为了泛化，所以为了不失一般性，一般只提取仅能用作成员函数的接口（构造函数、析构函数、下标运算符Operator[]等）的功能。换句话说，如果有一个功能是在仅能用作成员函数的接口中实现的，并且意图把功能应用到其他类时，CRTP是一个不错的选择。
