加qq1126137994 微信：liu1126137994 一起学习更多技术！！！

1、多参数类模板

类模板可以定义任意多个不同的类型参数

类模板可以被特化：

  • 指定类模板的特定实现
  • 部分类型参数必须显示指定
  • 根据类型参数分开实现类模板

类模板的特化类型：

  • 部分特化
    *用特定规则约束类型参数
  • 完全特化
    *完全显示指定类型参数

看代码：

#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;
}

运行结果：

类模板特化注意事项：

  1. 特化，只是模板的分开实现
    *本质上是同一个类模板
  2. 特化后的模板使用方式是统一的
    *必须显示指定每一个类型参数

2、特化的深度分析

问题：
1、类模板与重定义的区别？
2、函数模板可以特化么？

重定义和特化的不同：

  1. 重定义
    *重定义后，一个是类模板，定以后的是一个新类（即两个类模板）
    *使用的时候需要考虑如何选择的问题
  2. 特化
    *特化后的类与类模板是同一个类，以统一的方式使用类模板和特化后的类
    *编译器优先自动选择特化类

函数模板只支持类型参数完全特化：

看代码：

#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;
}

注意：当需要重载函数模板时，优先考虑模板特化，当模板特化无法满足要求时，再进行函数重载

3、总结

  1. 类模板可以定义任意多个不同类型的参数
  2. 类模板可以被部分特化和完全特化
  3. 特化的本质是模板的分开实现
  4. 函数模板只支持完全特化
  5. 工程中一般使用模板特化代替（函数）重定义