59 - 类模板与函数模板的深度剖析

---- 整理自狄泰软件唐佐林老师课程

1. 多参数模板

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

2. 类模板可以被 特化

模板本来是一组通用逻辑的实现，但是可能存在特定的参数类型下，通用的逻辑实现不能满足要求，这时就需要针对这些特殊的类型，而实现一个特例模板——即 模板特化。

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

2.1 类模板的特化类型

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

// 主模板类
template <typename T1, typename T2> 
class Test
{
};

// 完全特化
template < > 
class Test<int, int>
{
};

// 部分特化：对部分模板参数进行特化为一般类型
template <typename T2> 
class Test<int, T2>
{
};

// 部分特化：模板参数特化为指针
template <typename T1, typename T2> 
class Test<T1*, T2*>
{
};

2.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
< 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;
}

2.3 类模板特化注意事项

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

3. 特化的深度分析

3.1 问题

类模板特化与重定义有区别吗？函数模板可以特化吗？

3.2 重定义和特化的不同

• 重定义
  • 一个类模板和一个新类（或者两个类模板）
  • 使用的时候需要 考虑如何选择的问题
• 特化
  • 以统一的方式使用类模板和特化类
  • 编译器自动优先选择特化类

3.3 函数模板的特化

部分内容引用修改自：
https://blog.csdn.net/zhaominyong/article/details/109265862

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

// 常规函数
bool Equal(const char* left, const char* right)
{
}

// 函数主模板
template<typename T1, typename T2> 
bool Equal(T1 left, T2 right)
{
}

// 函数模板的完全特化
template< > 
bool Equal<void*>(void* left, void* right)
{
}

// 函数模板的重载（新的函数模板）
template<typename T1, typename T2> 
bool Equal(T1* left, T2* right)
{
}

3.3.2 函数模板之间的重载决议

#include <iostream>
using namespace std;

// 函数主模板
template<typename T1, typename T2>
void Equal(T1 left, T2 right)
{
    cout << "template<typename T1, typename T2> void Equal(T1 left, T2 right)" << endl;
}

// 函数模板的完全特化
template< >
void Equal(const char* left, const char* right)
{
    cout << "template< > void Equal<const char*>(const char* left, const char* right)" << endl;
}

// 函数模板的重载（新的函数模板）
template<typename T1, typename T2>
void Equal(T1* left, T2* right)
{
    cout << "template<typename T1, typename T2> void Equal(T1* left, T2* right)" << endl;
}

int main()
{
    Equal("1", "2");

    return 0;
}

#include <iostream>
using namespace std;

// 函数主模板
template<typename T1, typename T2>
void Equal(T1 left, T2 right)
{
    cout << "template<typename T1, typename T2> void Equal(T1 left, T2 right)" << endl;
}

// 函数模板的重载（新的函数模板）
template<typename T1, typename T2>
void Equal(T1* left, T2* right)
{
    cout << "template<typename T1, typename T2> void Equal(T1* left, T2* right)" << endl;
}

// 函数模板的完全特化
template< >
void Equal(const char* left, const char* right)
{
    cout << "template< > void Equal<const char*>(const char* left, const char* right)" << endl;
}

int main()
{
    Equal("1", "2");

    return 0;
}

3.3.3 普通函数与函数模板间的重载决议

#include <iostream>
using namespace std;

// 函数主模板
template<typename T1, typename T2>
void Equal(T1 left, T2 right)
{
    cout << "template<typename T1, typename T2> void Equal(T1 left, T2 right)" << endl;
}

// 函数模板的完全特化
template< >
void Equal(const char* left, const char* right)
{
    cout << "template< > void Equal<const char*>(const char* left, const char* right)" << endl;
}

// 函数模板的重载（新的函数模板）
template<typename T1, typename T2>
void Equal(T1* left, T2* right)
{
    cout << "template<typename T1, typename T2> void Equal(T1* left, T2* right)" << endl;
}

// 普通函数
void Equal(const char* left, const char* right)
{
    cout << "void Equal(const char* left, const char* right)" << endl;
}

int main()
{
    Equal("1", "2");

    return 0;
}

3.4 编程实验：特化的深入理解

#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.5 工程中的建议

• 当需要重载函数模板时，优先考虑使用模板特化
• 当模板特化无法满足需求时，再使用函数重载（如上例）

4. 小结

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