C++模板元模板实战书籍讲解第一章（奇特的递归模板式以及小结和题目）

目录

前言

一、奇特的递归模版式？

二、CRTR的应用场景

2.1 静态多态

2.2 编译时代码生成和优化

2.3 静态接口扩展

2.4 Traits 和策略模式

2.5 模拟虚函数

三、小结

总结 

---

前言

一个深度学习框架的初步实现为例，讨论如何在一个相对较大的项目中深入应用元编程，为系统优化提供更多的可能。

以下是本书的原文《C++模板元编程实战》,由李伟先生所著写。

百度网盘链接:

链接：https://pan.baidu.com/s/1e4QIRSDEfCR7_XK6-j-19w 
提取码：57GP

---

一、奇特的递归模版式？

"奇特的递归模版式"（Curiously Recurring Template Pattern, CRTP）是一种设计模式，它使用模板继承和静态多态编程技术来实现一些高级的类型转换和行为扩展。

CRTP 的核心思想是通过模板继承的方式来实现静态多态。在 CRTP 中，通过定义一个模板基类，然后通过模板参数将派生类自身作为基类的模板参数传递进去。这样一来，派生类就可以从基类继承一些功能，并且可以在派生类中重定义和添加新的行为。

 CRTP 的使用方式：

template <typename Derived>
class Base {
public:
    void foo() {
        // 调用派生类的具体实现
        static_cast<Derived*>(this)->fooImpl();
    }
};

class Derived : public Base<Derived> {
public:
    void fooImpl() {
        // 派生类的具体实现
    }
};

在这个示例中，`Base` 是一个模板基类，需要一个派生类作为模板参数。`Base` 类中定义了一个 `foo` 函数，它通过静态转换将 `this` 指针转换为派生类指针，然后调用派生类的 `fooImpl` 函数。派生类 `Derived` 继承自 `Base<Derived>`，并实现了 `fooImpl` 函数来提供具体的行为。

二、CRTR的应用场景

2.1 静态多态

静态多态性是指在编译时期就确定函数调用的具体实现。使用 CRTP 可以实现静态多态，无需虚函数和运行时多态，从而提高性能。

示例代码如下：

template <typename Derived>
class Base {
public:
    void foo() {
        static_cast<Derived*>(this)->fooImpl();
    }
};

class Derived1 : public Base<Derived1> {
public:
    void fooImpl() {
        // Derived1 的具体实现
    }
};

class Derived2 : public Base<Derived2> {
public:
    void fooImpl() {
        // Derived2 的具体实现
    }
};

int main() {
    Derived1 d1;
    d1.foo();  // 调用 Derived1 的 fooImpl

    Derived2 d2;
    d2.foo();  // 调用 Derived2 的 fooImpl

    return 0;
}

2.2 编译时代码生成和优化

CRTP 可以通过在编译时期根据派生类的类型进行静态分析、优化和特殊化，以提供更高效的代码执行路径。

示例代码如下：

template <typename Derived>
class Base {
public:
    void process() {
        Derived* derived = static_cast<Derived*>(this);
        // 根据 Derived 类型执行特定的处理逻辑
        derived->preProcess();
        // ...
        derived->mainProcess();
        // ...
        derived->postProcess();
    }
};

class Derived1 : public Base<Derived1> {
public:
    void preProcess() {
        // Derived1 的 preProcess
    }

    void mainProcess() {
        // Derived1 的 mainProcess
    }

    void postProcess() {
        // Derived1 的 postProcess
    }
};

class Derived2 : public Base<Derived2> {
public:
    void preProcess() {
        // Derived2 的 preProcess
    }

    void mainProcess() {
        // Derived2 的 mainProcess
    }

    void postProcess() {
        // Derived2 的 postProcess
    }
};

int main() {
    Derived1 d1;
    d1.process();  // 根据 Derived1 的类型执行处理逻辑

    Derived2 d2;
    d2.process();  // 根据 Derived2 的类型执行处理逻辑

    return 0;
}

2.3 静态接口扩展

CRTP 可以在派生类中扩展和定制基类的接口，通过继承并重定义基类的虚函数或使用静态函数成员，派生类可以为基类添加新的操作或改变其行为。

示例代码如下：

template <typename Derived>
class Base {
public:
    virtual void foo() {
        static_cast<Derived*>(this)->fooImpl();
    }
};

class Derived1 : public Base<Derived1> {
public:
    void fooImpl() override {
        // Derived1 的 fooImpl
    }
};

class Derived2 : public Base<Derived2> {
public:
    void fooImpl() override {
        // Derived2 的 fooImpl
    }
};

int main() {
    Base<Derived1>* b1 = new Derived1();
    b1->foo();  // 调用 Derived1 的 fooImpl

    Base<Derived2>* b2 = new Derived2();
    b2->foo();  // 调用 Derived2 的 fooImpl

    delete b1;
    delete b2;

    return 0;
}

2.4 Traits 和策略模式

CRTP 可以用于实现 Traits（特性类）和策略模式，对类型进行查询、操作和特性描述。

示例代码如下：

template <typename Derived>
struct Trait {
    static void describe() {
        Derived::describeTrait();
    }
};

struct TraitImpl : public Trait<TraitImpl> {
    static void describeTrait() {
        // TraitImpl 的描述
    }
};

int main() {
    TraitImpl::describe();  // 调用 TraitImpl 中的描述函数

    return 0;
}

2.5 模拟虚函数

通过使用 CRTP，我们可以在运行时通过基类指针来调用派生类的具体实现。虽然这不是真正的虚函数，但在模拟多态性方面具有相似的效果。

示例代码如下：

template <typename Derived>
class Base {
public:
    void foo() {
        static_cast<Derived*>(this)->fooImpl();
    }
};

class Derived : public Base<Derived> {
public:
    void fooImpl() {
        // 派生类的具体实现
    }
};

int main() {
    Base<Derived>* base = new Derived();
    base->foo();  // 调用派生类的 fooImpl

    delete base;

    return 0;
}

三、小结

书中原图如下：

---

总结 

        书中留下六道练习题，会在下一章出代码示例与讲解，题目如下：

1. 对于元函数来说，数值与类型其实并没有特别明显的差异：元函数的输入可以是数值或类型，对应的变换可以在数值与类型之间进行。比如可以构造一个元函数，输入是一个类型，输出是该类型变量所占空间的大小---------这就是一个典型的从类型变换为数值的元函数。尝试构造该函数，并测试是否能行。

2. 作为进一步的扩展，元函数的输入参数甚至可以是类型与数值混合的。尝试构造一个元函数，其输入参数为一个类型以及一个整数。如果该类型所对应对象的大小等与该整数，那么返回true，否则返回false。

3. 本章介绍了若干元函数的表示形式，你是否还能想到其它的形式？

4.本章讨论了以类模板作为元函数的输出，尝试构造一个元函数，它接收输入后会返回一个元函数，后者接收输入后会再返回一个元函数------这仅仅是一个联系，不必过于在意其应用场景

5. 使用SFINAE构造一个元函数：输入一个类型T，当T存在子类型type时该元函数返回true，否则返回false。

6. 使用在本章中学到的循环代码书写方式，编写一个元函数，输入一个类型数组，输出一个无符号整形数组，输出数组中的每个元素表示输入数组中相应类型变量的大小。

7.使用分支短路逻辑实现一个元函数，给定一个整数序列，判断其中是否存在值为1的元素。如果存在，就返回true，否则返回false。