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

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

    1. 多参数模板

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

    在这里插入图片描述

    2. 类模板可以被 特化

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

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

    在这里插入图片描述

    2.1 类模板的特化类型

    • 部分特化：用特定规则约束类型参数
    • 完全特化：完全显示指定类型参数
    // 主模板类
template <typename T1, typename T2> 
class Test
{
};

    • 1
    • 2
    • 3
    • 4
    • 5
    // 完全特化
template < > 
class Test<int, int>
{
};

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

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

    • 1
    • 2
    • 3
    • 4
    • 5

    2.2 编程实验：类模板的特化

    #include 
#include 

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
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78

    在这里插入图片描述

    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)
{
}

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

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

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

    • 1
    • 2
    • 3
    • 4
    • 5

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

    #include 
using namespace std;

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

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

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

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

    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    在这里插入图片描述

    #include 
using namespace std;

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

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

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

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

    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    在这里插入图片描述

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

    #include 
using namespace std;

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

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    在这里插入图片描述

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

    #include 
#include 

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77

    在这里插入图片描述
    在这里插入图片描述

    3.5 工程中的建议

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

    4. 小结

    • 类模板可以定义任意多个不同的类型参数
    • 类模板可以被部分特化和完全特化
    • 特化的本质是模板的分开实现
    • 函数模板只支持完全特化
    • 工程中使用模板特化代替类（函数）重定义
  • 相关阅读:
    如何才能避免辛苦开发出来的产品惨遭市场冷遇？
    XPD738协议系列-USB Type-C PD 和 Type-A 双口控制器
    HTML常用标签
    linux使用stress命令进行压力测试cpu
    软件测试--编写测试计划
    07.JAVAEE之线程5
    AntV的g6库纵向的紧凑树形节点之间箭头被覆盖
    特征工程建模可解释包（note）
    clickhouse分布式之弹性扩缩容的故事
    【C++ Primer Plus学习记录】复合类型总结
  • 原文地址：https://blog.csdn.net/weixin_36098975/article/details/128093389