C++ template随笔

Posted 2020-06-11

话题从重用开始说起：

最基本的重用，重用一个方法，被重用的逻辑被抽取封装成为方法，之后我们把方法当成一种工具来使用（处理数据，输入输出，或者改变状态）。

来到了面向对象的时代，如果这个方法出现父类上面就是继承，如果这个方法出现在其他对象上就是代理，如果子类想要重用父类的接口又不想重用实现那么就是多态。

但是这些重用都是基于相同的数据类型，方法创建出来后接收参数都是固定的类型，对于多态，可以通过子类来实现不同行为，但是方法总归还是接收一个固定父类型（或者接口）参数。

想想有没有这样的需求，两个完全不同的类型，他们之间不存在继承关系，但是却需要同样的处理逻辑，比如说各种类型都需要排序，比如说各种类型都有集合处理的需求。

那么能不能让方法接收不同类型来实现重用呢？C++的Template就是解决这样问题。

 

模板方法

既然这样需求不同类型却需要相同处理方法，所以有了模板方法，

template<typename T>
T Add(T a, T b)
{
    return a + b;
};

int main()
{
    string s1 = "Hello";
    string s2 = "World";
    cout << Add(12,13) << endl;
    cout << Add(s1,s2) << endl;

    return 0;

}; 输出： 25 HelloWorld

 模板类

方法都能模板化，那么类怎么能够不模板化， 作为面向对象的C++，所以有了模板类

把这些模板方法组合起来，再加上模板成员就形成了一个模板类，这些概念和行为和一般的类是一样的。

 

template<typename T>
class Calculator
{
public:
    T m_variable;
    virtual T Add(T a, T b)
    {
        return a + b;
    };

    T Minus(T a, T b)
    {
        return a - b;
    };
};

int main()
{
    Calculator<int> c;
    cout << c.Add(2,3) << endl;
    cout << c.Minus(9,5) << endl;

    string s1 = "Hello";
    string s2 = "World";
    Calculator<string> d;
    cout << d.Add(s1,s2) << endl;
    //cout << d.Minus(s1,s2) << endl;

    return 0

} 

 

想想为什么最后那句注释可以编译过，但是打开那句就编译不过了。

我的理解，当模板类实例化的过程，如果没有用到的方法不会被加入被实例化的模板类中，除非你显示调用了模板类的方法。

模板类继承

既然是类，当然不能少了继承，模板类的继承可以分为

直接从模板类继承

template<typename T>
class SuperCalculator : public Calculator<T>
{
public:
    T m_variable;
    virtual T Add(T a, T b)//多态
    {
        return a + b + b;
    };

    T Multi(T a, T b)//子类
    {
        return a * b;
    };
};

 
int main()
{
    SuperCalculator<int> sc;
    cout << sc.Add(2,3) << endl;
    cout << sc.Minus(9,5) << endl;
    cout << sc.Multi(9,5) << endl;
    return 0;
};

输出 8,4,45

从具体类继承

class SuperIntCalculator: public Calculator<int>
{
public:
    virtual int Add(int a, int b)
    {
        return a + b + a;
    };

    int Multi(int a, int b)
    {
        return a * b;
    };
};

int main()
{
    SuperIntCalculator sc;
    cout << sc.Add(2,3) << endl;
    cout << sc.Minus(9,5) << endl;
    cout << sc.Multi(9,5) << endl;


    return 0;
};

输出 7, 4, 45

 

模板特例化（偏特化） 

模板类可以通过继承可以在垂直方向变化，但是类型本身也是一个水平的维度，C++为这个维度提供了变化，对于某种具体类的模板类可以拥有特殊的行为，因此我们成为特例化。

template<typename T>
class TClass
{
public:
    void PrintInfo()
    {
        printf("Hello common\n");
    };
};

template<>
class TClass<int>//特例化
{
public:
    void PrintInfo()
    {
        printf("Hello int\n");
    };
};

template<typename T>
TClass<T> * GetTClassObject(T a)
{
    return new TClass<T>;
};


int main()
{
    GetTClassObject("Hello")->PrintInfo();
    GetTClassObject(4.5)->PrintInfo();
    GetTClassObject(5)->PrintInfo();

    return 0;
};

输出
Hello Common
Hello Common
Hello Int

如果一个模板类需要接受两个或者两个以上的类型来实现具体类，当其中一个类型是某个具体类的时候有特殊的行为，那么就成为偏特化。

继承是垂直方向上的特例化，但是特例化不是传统面向对象体系中的概念，可以类比但不要混淆，特例化是是另外一个维度（水平），因此特例化不仅仅可以作用在类上，也能作用在模板方法上。

 

比较

>>模板和模板模式（Template Method Design Pattern）

这个设计模式也是来解决不同类型的却有相同的处理逻辑，这个思想是一致的。但是实现却不同，模板模式由子类去实现模板方法的每一个步骤（或者某个步骤），而且这个模式的假设是所有的类型都是来自于相同的基类，没有解决我们最开始非固定类型。C++模板实现逻辑在类型外面（怎么感觉又有点像策略模式，但是策略模式需要相同的接口或者基类），而类型本身可以针对不同基类的类型。其实对于模板类（方法）而言，他们虽然没有共同的基类，但是再仔细想想，要在一个模板类中类型需要有一个抽象共性，但是这个共性不是以基类形式来表达，比如说排序，那么输入类型必须都要能比较大小，比如说集合，那么输入类型都要有“一个一个”的概念（好像不好理解，vector能处理流体问题吗？）

>>模板和宏

这两个东西很容易放在一起说，比如一个简单模板类可以通过宏来实现没有问题。

但是两者是从不同角度来解决重用问题的，模板是为不同类型提供相同逻辑的重用，是站在类型的角度上看问题。宏是为代码级别的重用，站在少写代码的角度来看问题。

所以他们有重叠的部分。也提供对方不能提供的功能