第59课 类模板深度剖析

多参数类模板：

特化：

上图特化的意义是将原来接收任意两个类型参数的模板特化为只能接收一种类型的两个参数。

这意味着如果定义类时我们给的两个参数是同种类型的，则编译器优先使用右边的这种模板实现。

一个类模板实际分开实现为两个部分，编译器根据具体的参数选择其中的一个模板。

编译器会认为上图中的两个Test模板是同一个，具体实现时，如参数类型不同则选择左边的实现，参数类型相同时选择右边的实现。

 完全特化就是我们根本就不需要泛指参数了，直接指定原先的泛指类型全部为int，完全特化意味着特化之后的模板里面已经没有了泛指类型。

当我们使用模板时，如果指定了参数都为int，则编译器选择右边的实现。

示例程序：

编译器并不认为第20行是一个新的模板，只是认为它是第7行那个模板的一个特殊实现。

 使用double*和int*来生成类：

Test<int*, double*> t4;
    int a = 1;
    double b = 0.1;
    
    t4.add(&a, &b);

这次匹配到了第7行的这个模板实现，但是第二次编译时，编译器提示我们两个不同的指针类型无法相加。

因此，我们继续添加指针参数的特化。

继续完善：

#include <iostream>
#include <string>

using namespace std;

template
< typename T1, typename T2 >
class Test
{
public:
    void add(T1 a, T2 b)
    {
        cout << "void add(T1 a, T2 b)" << endl;
        cout << a + b << endl;
    }
};

template
< typename T1, typename T2 >
class Test < T1*, T2* >      // 关于指针的特化实现
{
public:
    void add(T1* a, T2* b)
    {
        cout << "void add(T1* a, T2* b)" << endl;
        cout << *a + *b << endl;
    }
};

template
< typename T >
class Test < T, T >    // 当 Test 类模板的两个类型参数完全相同时，使用这个实现
{
public:
    void add(T a, T b)
    {
        cout << "void add(T a, T b)" << endl;
        cout << a + b << endl;
    }
    void print()
    {
        cout << "class Test < T, T >" << endl;
    }
};

template
<  >
class Test < void*, void* >    // 当 T1 == void* 并且 T2 == void* 时
{
public:
    void add(void* a, void* b)
    {
        cout << "void add(void* a, void* b)" << endl;
        cout << "Error to add void* param..." << endl;
    }
};

int main()
{  
    Test<int, float> t1;
    Test<long, long> t2;
    Test<void*, void*> t3;
    
    t1.add(1, 2.5);
    
    t2.add(5, 5);
    t2.print();
    
    t3.add(NULL, NULL);
    
    Test<int*, double*> t4;
    int a = 1;
    double b = 0.1;
    
    t4.add(&a, &b);
    
    return 0;
}

以上的四个类模板是一个模板，只不过有几种不同的特化方式。

结果如下：

 多参数类模板：

问题：

特化的深度分析：

 示例：

我们将void* 指针参数的特化注释掉，重新定义Test_Void类，第75行也改成Test_Void类名字，这样也能正常工作。

但是，在我们编程时要时刻想着到底是使用类模板呢还是Test_Void类呢？这无疑增加了负担，所以能用类模板特化的就用特化，不能特化的再重新定义类。

函数模板示例：

上图中我们得到了正确的结果，但是我们知道两个浮点数比较不能直接用45行的比较方法，因此，我们需要特化。

改进如下：

从打印结果看，double类型确实调用到了第52行的特化版本。

再添加一个直接重载的版本：

#include <iostream>
#include <string>

using namespace std;

template
< typename T1, typename T2 >
class Test
{
public:
    void add(T1 a, T2 b)
    {
        cout << "void add(T1 a, T2 b)" << endl;
        cout << a + b << endl;
    }
};

/*
template
<  >
class Test < void*, void* >    // 当 T1 == void* 并且 T2 == void* 时
{
public:
    void add(void* a, void* b)
    {
        cout << "void add(void* a, void* b)" << endl;
        cout << "Error to add void* param..." << endl;
    }
};
*/

class Test_Void
{
public:
    void add(void* a, void* b)
    {
        cout << "void add(void* a, void* b)" << endl;
        cout << "Error to add void* param..." << endl;
    }
};

template
< typename T >
bool Equal(T a, T b)
{
    cout << "bool Equal(T a, T b)" << endl;
    
    return a == b;
}

template
< >
bool Equal<double>(double a, double b)
{
    const double delta = 0.00000000000001;
    double r = a - b;
    
    cout << "bool Equal<double>(double a, double b)" << endl;
    
    return (-delta < r) && (r < delta);
}

bool Equal(double a, double b)
{
    const double delta = 0.00000000000001;
    double r = a - b;
    
    cout << "bool Equal(double a, double b)" << endl;
    
    return (-delta < r) && (r < delta);
}

int main()
{  
    cout << Equal( 1, 1 ) << endl;
    cout << Equal<>( 0.001, 0.001 ) << endl;
    
    return 0;
}

 运行结果如下：

当第76行为cout << Equal(0.001, 0.001) << endl 时，结果如下：

调用的是我们的重载的函数版本。

当第76行为cout << Equal<>(0.001, 0.001) << endl 时，调用的是函数模板特化版本，如下：

工程中的建议：

 小结：