【C++】泛型编程 —— template 模板的运用

毕瞿三谲丶

已于 2024-08-10 18:48:50 修改

阅读量896

点赞数 10

分类专栏： C/C++ 文章标签： c++ 算法开发语言

于 2024-08-10 11:10:59 首次发布

本文链接：https://blog.csdn.net/qq_45666995/article/details/141087799

版权

C/C++ 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

非类型模板参数

通常情况下，我们可以通过类型模板参数来使用容器存放不同类型的数据，但有时我们会用到非类型模板参数。

类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参：用一个常量作为类（函数）模板的一个参数，在类（函数）模板中可将该参数当成常量来使用

// 定义一个模板类型的静态数组
template <typename T, size_t N = 16>
class stack
{
    // ...
private:
    T m_a[N];
    size_t m_size;
};

注意：
1. 浮点数、类对象以及字符串不允许作为非类型模板参数，非类类型模板的形参只能是整型、指针和引用。
2.非类型模板形参如果是表达式，则必须是一个常量表达式，在编译时计算出结果。
3.非类类型模板形参和实参间允许类型转换

模板的特化

概念

通常情况下，使用模板可以实现一些不同类型的代码，但对于一些特殊类型可能会得到错误的结果，如下例：

#include<iostream>

using std::cout;
using std::cin;
using std::endl;

class Date
{
public:
    Date(int year = 1970, int month = 1, int day = 1) 
        : m_year(year)
        , m_month(month)
        , m_day(day)
    {}

    ~Date() {}

    bool operator<(const Date& right) const
    {
        if (m_year < right.m_year)
            return true;
        else if (m_year == right.m_year)
        {
            if (m_month < right.m_month)
                return true;
            else if (m_month == right.m_month)
            {
                if (m_day < right.m_day)
                    return true;
            }
        }
        return false;
    }

private:
    int m_year;
    int m_month;
    int m_day;
};

template<typename T>
bool Less(T left, T right)
{
    return left < right;
}

int main()
{
    // 结果正确
    cout << Less(15, 25) << endl;

    // 结果正确
    cout << Less(Date(2001, 3, 4), Date(2001, 3, 5)) << endl;
    
    Date d1(2019, 6, 1);
    Date d2(2020, 6, 1);
    // 比较的是地址，结果错误
    cout << Less(&d1, &d2) << endl;

    return 0;
}

上例中，Less 在绝大多数情况下都可以正常比较，但在特殊场景下就会出现错误，如 Less 的参数为需比较的对象的地址，上例中为 Date*，此时，模板将 Date* 推演为T，因此 Less 比较的就是两个 Date* 类型的变量的大小，这与我们预想的结果相差甚远。

此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

函数模板特化

函数模板的特化步骤：

必须要先有一个基础的函数模板
关键字 template 后面接一对空的尖括号<>
函数名后跟一对尖括号，尖括号中指定需要特化的类型
函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

template<typename T>
bool Less(T left, T right)
{
    return left < right;
}

// 函数模板特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
    return *left < *right;
}

类模板特化

全特化

全特化是将模板参数列表中所有的参数都确定化。

template<typename T1, typename T2>
class Date
{
public:
    Date(const T1& v1, const T2& v2)
        : m_v1(v1)
        , m_v2(v2)
    {
        cout << "Date(const T1& v1, const T2& v2)" << endl;
    }
private:
    T1 m_v1;
    T2 m_v2;
};

// 全特化
template<>
class Date<int, double>
{
public:
    Date(int v1, double v2)
        : m_v1(v1)
        , m_v2(v2)
    {
        cout << "Date(int v1, double v2)" << endl;
    }
private:
    int m_v1;
    double m_v2;
};

int main()
{
    Date<int, char> d1(1, 'a');    // 调用基础类模板
    Date<int, double> d2(10, 1.1); // 调用全特化的版本

    return 0;
}

偏特化

偏特化是指任何针对模版参数进一步进行条件限制设计的特化版本。

// 偏特化
template<typename T1>
class Date<T1, double>
{
public:
    Date(const T1& v1, double v2)
        : m_v1(v1)
        , m_v2(v2)
    {
        cout << "Date(const T1& v1, double v2)" << endl;
    }
private:
    T1 m_v1;
    double m_v2;
};

// 进一步的偏特化
// 两个参数偏特化为指针类型
template<typename T1, typename T2>
class Date<T1*, T2*>
{
public:
    Date(const T1* const v1, const T2* const v2)
        : m_v1(*v1)
        , m_v2(*v2)
    {
        cout << "Date(const T1* const v1, const T2* const v2)" << endl;
    }
private:
    T1 m_v1;
    T2 m_v2;
};

// 两个参数偏特化为引用类型
template<typename T1, typename T2>
class Date<T1&, T2&>
{
public:
    Date(const T1& v1, const T2& v2)
        : m_v1(v1)
        , m_v2(v2)
    {
        cout << "Date(const T1& v1, const T2& v2)" << endl;
    }
private:
    const T1& m_v1;
    const T2& m_v2;
};

int main()
{
    Date<int, int> d1(1, 2);         // 调用基础类模板
    Date<int, double> d2(1, 2.2);    // 调用偏特化第二个参数的版本
    int x = 10;
    char y = 'y';
    Date<int*, char*> d3(&x, &y);    // 调用偏特化为指针的版本
    Date<int&, char&> d4(x, y);      // 调用偏特化为引用的版本

    return 0;
}

模板分离编译

问题

通常情况下，我们会把函数和类的声明放在一个.h头文件里，在另一个.cpp文件里实现，但如果模板也采用这种策略，则会出现错误，如下例：

// less.h
template<typename T>
bool Less(const T& left, const T& right);

// less.cpp
#include"less.h"
template<typename T>
bool Less(const T& left, const T& right)
{
    return left < right;
}

// main.cpp
#include<iostream>
#include"less.h"
int main()
{
    std::cout << Less(1, 2) << std::endl;
    std::cout << Less(1.1, 2.2) << std::endl;
    return 0;
}

C/C++程序的运行需要经历以下步骤：

预处理 ---> 编译 ---> 汇编 ---> 链接

预处理：a.头文件展开；b.去注释；c.宏替换；d.条件编译

编译：对程序按照语言特性进行词法、语法、语义分析，检查无误后生成汇编代码，编译器对工程中的多个源文件是分离开单独编译的。

汇编：将编译好的汇编代码转化为.obj二进制文件

链接：将多个.obj文件合并为一个

上例中，在Less.cpp文件里没有Less函数的实例化，不会生成对应的函数，也就没有函数地址，但main.obj在链接时才会寻找Less的地址，而Less函数没有实例化，没有生成具体函数，因此链接时报错。

解决方案

main.cpp 里 #include "less.cpp"，但是会减慢编译速度。
在模板函数或模板类定义的文件里添加显式实例化的内容，上例中可在 less.cpp 里添加如下代码：
```
template
bool Less<int>(const int&, const int&);

template
bool Less<double>(const double&, const double&);
```
模板函数或模板类的声明和定义直接写在头文件里（实际工作中常用）。