C++模板

目录

一、模板简介

1.1 泛型编程

1.2 函数模板        

1.2.1 函数模板概念

1.2.2 函数模板格式

1.2.3 函数模板的原理

1.2.4 函数模板的实例化

1.2.5 模板参数的匹配原则

1.3 类模板        

1.3.1 类模板的定义格式

1.3.2 类模板的实例化

二、模板进阶

2.1 非类型模板参数

extra array 

2.2 类模板的特化

2.2.1 概念理解

2.2.2 函数模板特化

2.2.3 类模板特化        

2.3 模板的分离编译

2.3.1 模板的分离编译

​2.3.2 解决方法

总结

---

一、模板简介

1.1 泛型编程

实现一个通用的交换函数Swap    

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}
void Swap(double& left, double& right)
{
    double temp = left;
    left = right;
    right = temp;
}
void Swap(char& left, char& right)
{
    char temp = left;
    left = right;
    right = temp;
}

//... ...

使用函数重载虽然可以实现，但是也有几个不好的地方：
1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
2. 代码的可维护性较低，一个出错可能导致所有的重载均出错

现实生活中，如果需要复刻很多相似甚至相同的物品，一般都会先制造一个模板。那能否给编译器一个模版，让编译器根据不同的类型利用该模版来生成代码呢？
如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础
        

1.2 函数模板        

1.2.1 函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本

1.2.2 函数模板格式

template
返回值类型 函数名(参数列表){}

1.1 中的代码可以简化成如下形式

template
void Swap(T& left, T& right)
{
    T temp = left;
    left = right;
    right = temp;
}

typename是用来定义模板参数关键字，也可以使用class(不能使用struct代替class)

1.2.3 函数模板的原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器
Swap(i, j), Swap(m, n), Swap(c1, c2) 调用的不是同一个函数

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码

1.2.4 函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。
1. 隐式实例化：让编译器根据实参推演模板参数的实际类型

template
T Add(const T& left, const T& right)
{
    return left + right;
}

int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    Add(a1, a2);
    Add(d1, d2);

    // 下面两条语句可以通过编译吗
    Add(a1, d1);
    Add(a, (int)d);

    return 0;
}

第一条语句不能通过编译，因为在编译期间，当编译器实例化时，需要根据实参类型推演T
通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
编译器无法确定此处到底该将T确定为int 或者 double类型而报错

// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化

2. 显式实例化：在函数名后的<>中指定模板参数的实际类型

int main(void)
{
    int a = 10;
    double b = 20.0;
    // 显式实例化
    Add(a, b);
    return 0;
}

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错

1.2.5 模板参数的匹配原则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}
// 通用加法函数
template
T Add(T left, T right)
{
    return left + right;
}
void Test()
{
    Add(1, 2);          // 与非模板函数匹配，编译器不需要特化
    Add(1, 2);     // 调用编译器特化的Add版本
}

2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}

// 通用加法函数
template
T1 Add(T1 left, T2 right)
{
    return left + right;
}
void Test()
{
    Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
    Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数 
}

3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

        

1.3 类模板        

1.3.1 类模板的定义格式

template
class 类模板名
{
    // 类内成员定义
};

// 动态顺序表

template
// Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
class Vector
{
public :
    Vector(size_t capacity = 10)
    : _pData(new T[capacity])
    , _size(0)
    , _capacity(capacity)
    {}
// 使用析构函数演示：在类中声明，在类外定义。
    ~Vector();
    void PushBack(const T& data)；
    void PopBack()；
    // ...
    size_t Size() 
    {
        return _size;
    }
    T& operator[](size_t pos)
    {
        assert(pos < _size);
        return _pData[pos];
    }
private:
    T* _pData;
    size_t _size;
    size_t _capacity;
};

// 类模板中函数放在类外进行定义时，需要加模板参数列表
template 
Vector::~Vector()
{
    if(_pData)
    delete[] _pData;
    _size = _capacity = 0;
}

1.3.2 类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类

// Vector类名，Vector才是类型
Vector s1;
Vector s2;

        

---

二、模板进阶

2.1 非类型模板参数

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

示例——使用模板定义一个静态栈

// 非类型模板参数 -- 只支持整形(char, short, int, long...)
template
class Stack
{

private:
    T _a[N];
};

// 传参（必须是常量）分配静态栈的大小
Stack st1;
Stack st2;

// 如果传参的时候用变量，模板实例化的时候_a[N]应该开辟多大的空间呢？
int n = 0;
cin >> n;
Stack st1;    // error

        

extra array 

插入一条知识点——arrayarray - C++ Reference (cplusplus.com)https://legacy.cplusplus.com/reference/array/array/?kw=array

        静态数组array也使用了非类型模板参数，array与C语言中的数组非常相似，除此之外，array具有严格的越界检查，而C语言的数组只是抽查是否越界，我们可以看一段代码和运行结果观察一下：

尽管array的越界检查更严格，但我们为何不使用vector呢？        

      

2.2 类模板的特化

2.2.1 概念理解

我们通过一段代码来更好地了解特化的概念：

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊的类型
可能会得到一些错误的结果，需要特殊处理。
比如：实现了一个用来进行小于比较的函数模板，但是想比较两个指针指向的空间的大小

// 函数模板
template
bool Less(T left, T right)
{
    return left < right;
}

// 函数特化
// 如果 T 的类型为Date* 则会实例化下面这个类
// template<>                       // 语法格式
// bool Less(Date* left, Date* right)
// {
//     return *left < *right;
// }

int main()
{
    cout << Less(1, 2) << endl;     // 可以比较，结果正确
    Date d1(2023, 10, 1);
    Date d2(2023, 10, 6);
    cout << Less(d1, d2) << endl;   // 可以比较，结果正确
    Date* p1 = &d1;
    Date* p2 = &d2;
    cout << Less(p1, p2) << endl;   // 可以比较，结果错误
                                    // 函数特化后结果正确
    return 0;
}

        

2.2.2 函数模板特化

// 函数模板 -- 参数匹配
// 实例化的时候会选择参数最匹配的模板
template
bool Less(T left, T right)
{
    return left < right;
}

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

template<>
bool Less(Date* left, Date* right)
{
    return *left < *right;
}

 实际上，我们也会使用下面的方法解决2.2.1中的问题，避开参数类型复杂的函数模板       

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

// 下面这段代码特化正确吗?
template<>
bool Less(const Date* & left, const Date* & right)
{
    return *left < *right;
}
// 正确的方式是这样的
template<>
bool Less(Date* const & left, Date* const & right)
{
    return *left < *right;
}

// 注意：这既不是特化，也不与上面的构成函数重载(因为上面的是函数模板，不是函数
bool Less(Date* left, Date* right)
{
    return *left < *right;
}

这种方式实现起来简单明了，代码的可读性高，不容易出错。因此对于一些参数类型复杂的函数模板，不建议特化

2.2.3 类模板特化        

// 模板特化：针对某些类型进行特殊化处理
template
class Data
{
public:
    Data() { cout << "Data" << endl; }
private:
    T1 _d1;
    T2 _d2;
};

// 特化
template<>
class Data
{
public:
    Data() { cout << "Data" << endl; }
};

// 特化
template
class Data
{
public:
    Data() { cout << "Data" << endl; }
};

类的对象会从类模板以及它的特化中选择最符合自己的进行实例化

        

全特化与偏特化

template
class Data
{
public:
    Data() { cout << "Data" << endl; }
private:
    T1 _d1;
    T2 _d2;
};

// 全特化
template<>
class Data
{
public:
    Data() { cout << "Data" << endl; }
};

// 偏特化
template
class Data
{
public:
    Data() { cout << "Data" << endl; }
};



template
class Less
{
public:
    bool operator()(const T& x, const T& y)
    {
        return x < y;
    }
};

template<>
class Less
{
public:
    bool operator()(Date* x, Date* y)
    {
        return *x < *y;
    }
};

template
class Less
{
public:
    bool operator()(T* x, T* y)
    {
        return *x < *y;
    }
};

2.3 模板的分离编译

回顾一下分离编译的概念：一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式

2.3.1 模板的分离编译

假如有以下场景，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义：

// a.h
template
T Add(const T& left, const T& right);

// a.cpp
template
T Add(const T& left, const T& right)
{
return left + right;
}

// main.cpp
#include"a.h"
int main()
{
Add(1, 2);
Add(1.0, 2.0);
return 0;
}

我们可以看到两个链接错误：

test.obj : error LNK2019: 无法解析的外部符号 "int __cdecl Add(int const &,int const &)" (??$Add@H@@YAHAEBH0@Z)，函数 main 中引用了该符号
test.obj : error LNK2019: 无法解析的外部符号 "double __cdecl Add(double const &,double const &)" (??$Add@N@@YANAEBN0@Z)，函数 main 中引用了该符号 

2.3.2 解决方法

1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种

2. 模板定义的位置显式实例化。这种方法不实用。不推荐使用
        

---

总结

【优点】
1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
2. 增强了代码的灵活性
【缺陷】
1. 模板会导致代码膨胀问题，也会导致编译时间变长
2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误