模板与泛型编程

天穹南都

已于 2023-12-11 00:06:14 修改

阅读量941

点赞数 22

文章标签： c++ 开发语言

于 2023-12-09 11:51:47 首次发布

本文链接：https://blog.csdn.net/b1169909203/article/details/134860557

版权

函数模板

显示实例化

区别定义与声明

T是模板形参 int是模板实参

inpunt是函数形参 3是函数实参

显示实例化

模板必须实例化可见翻译单元一处定义原则

与内联函数异同

引入原因：函数模板是为了编译器两个阶段的处理内联函数是为了能在编译期展开

模板实参的类型推导

推导原则

推导规则示例

函数形参是左值引用/指针：
- 忽略表达式类型中的引用
- 将表达式类型与函数形参模式匹配以确定模板实参

2.万能引用：函数模板的 T&&是万能引用

如果实参表达式是右值，那么模板形参被推导为去掉引用的基本类型
如果实参表达式是左值，那么模板形参被推导为左值引用，触发引用折叠

引用折叠：当有两个引用相互绑定时，它们会被折叠成一个引用。在模板实例化期间，引用折叠规则被应用于模板参数。

3、

函数形参不包含引用
- 忽略表达式类型中的引用
- 忽略顶层const
- 数组、函数转换成相应的指针类型

无法推导的情况

模板实参并非总是能够推导得到
- 如果模板形参与函数形参无关，则无法推导
- 即使相关，也不一定能进行推导，推导成功也可能存在因歧义而无法使用

即使相关，也不一定能进行推导，推导成功也可能存在因歧义而无法使用

在无法推导时，编译器会选择使用缺省模板实参
- 可以为任意位置的模板形参指定缺省模板实参——注意与函数缺省实参的区别

但是缺省只能处理无法推导的情况不能处理能推导但是有歧义的情况

模板缺省实参和函数缺省实参区别

函数缺省实参要从右向左设置。模板可以不是

自动推导遇到的几种情况

1.SPFINAE

函数模板中的替换失败（Substitution Failure Is Not An Error，简称 SFINAE）是一种编译器处理模板实例化失败的机制。当尝试实例化一个模板时，如果由于某些原因导致实例化失败，编译器并不会报错，而是会尝试使用备选的模板或者进行其他处理。

报错：没有匹配的函数、忽视函数

重载函数匹配失败就会找其他模板实例化忽略掉前一个

2.模板与非模板同时匹配，匹配等级相同，此时选择非模板的版本

下面的代码调用了非模板的fun函数

注意是匹配等级相同的情况才会选择非模板如果不同则会选择更加完美的匹配

下面的代码会调用模板fun

3.多个模板同时匹配，此时采用偏序关系确定选择最特殊的版本

float更加特殊所以匹配第二个fun

如果同样特殊就会报错

标准类型转换模板

尾置返回类型与类型转换

显式实例化定义：template void fun(int) / template void fun(int)

显式实例化声明：extern template void fun(int) / extern template void fun(int)

注意一处定义原则
来源：stackoverflower

注意实例化过程中的模板形参推导

模板特化

函数模板的（完全）特化：

template<> void f(int) / template<> void f(int)

并不引入新的（同名）名称，只是为某个模板针对特定模板实参提供优化算法

避免使用模板的特化

不参与重载解析，会产生反直觉的效果
通常可以用重载代替
一些不便于重载的情况：无法建立模板形参与函数形参的关联

1.if constexpr解决

2.假函数解决

函数模板不能偏特化

C++20auto定义模板参数

类模板

成员函数只有在调用时才会被实例化

证明：程序无法编译但是去掉21行就能编译

类内类模板名称的简写

类模板成员函数类外定义

成员函数模板

类的成员函数模板

类模板的成员函数模板

类内定义

类外定义

友元函数模板

fun是个友元函数模板

类模板的静态成员

成员对象只有类实例化的时候才会被实例化

static函数只有使用的时候才会实例化

C++11模板参数为友元

类模板的实例化

类模板的显示实例化

类模板特化

完全特化

偏特化

C++17类模板的实参推导

B x(3)自动推导成B<int>

pair的自动推导

C++17之前的解决方法函数模板推导

C++20新概念

模板的问题：没有对模板参数引入相应的限制
- 参数是否可以正常工作，通常需要阅读代码进行理解
- 编译报错友好性较差(vector<int&>)

（C++20）Concepts：编译期谓词，基于给定的输入，返回true或false
- 与constraints（require从句）一起使用时限制模板参数
- 通常置于表示模板形参的尖括号后面进行限制

此处限制T是int和float

优点：报错一目了然

Concept的定义与使用

1.包含一个模板参数的Concept
- 使用requires从句
- 直接替换typename

2.包含多个模板参数Concept
- 用做类型constraint时，少传递一个参数，推导出的类型将作为首个参数

requires 表达式 (C++20 起) - cppreference.com 参考资料

简单表达式：表明可以接收的操作

类型表达式：表明是一个有效的类型

requires从句所引入的限定具有偏序特性，系统会选择限制最严格的版本

如下 C1更严格编译器选择匹配C1

特化小技巧：在声明中引入“A||B”进行限制，之后分别针对A与B引入特化

模板的实现原理

模板需要编译两次，在第一次编译时仅仅检查最基本的语法，比如括号是否匹配。等函数真正被调用时，才会真正生成需要的类或函数。

所以这直接导致了一个结果，就是不论是模板类还是模板函数，声明与实现都必须放在同一个文件中。因为在程序在编译期就必须知道函数的具体实现过程。如果实现和声明分文件编写，需要在链接时才可以看到函数的具体实现过程，这当然会报错。

于是人们发明了.hpp文件来存放模板这种声明与实现在同一文件的情况。

重载与模板

数值模板参数与模板模板参数

模板可以接受编译器常量为模板参数

C++17auto value

C++20支持浮点数作为模板参数(clang 12不支持）

接受模板作为模板参数

C++17模板的模板考虑缺省实参

clang12支持有限

别名模板

为目标本身引入别名

为类模板的成员引入别名

别名模板不支持特化，但可以基于类模板的特化引入别名，以实现类似特化的功能
- 注意与实参推导的关系

变长模板

变长模板(Variadic Template)

变长模板参数与参数包

形参包（parameter pack）是C++中用于处理可变数量参数的一种特性。形参包可以接受任意数量的模板参数，并在模板中进行处理。

形参包的基本语法是使用...来表示，可以用在函数模板、类模板以及别的模板上下文中。形参包的展开可以通过递归、折叠表达式（C++17引入）等方式进行。

接数值

接类型

带可选名字的函数形参包

完美转发

右值引用失效

使用万能引用 T&&情况

还是失效原因：右值引用是个左值

解决方法：转发 forward

（C++11）完美转发：std::forward函数
- 通常与万能引用结合使用
- 同时处理传入参数是左值或右值的情形

包展开与折叠表达式

消除歧义

internal*p被编译器解读成乘法

使用typename与template消除歧义
- 使用typename表示一个依赖名称是类型而非静态数据成员

使用template表示一个依赖名称是模板

T::internal<A 会被编译器视为小于号比较大小

使用template表示一个依赖名称是模板

template与成员函数模板调用

internal被解读为依赖obj <被解读成小于号

解决方法

C++14变量模板

（C++14）变量模板
- template<typename T> T pi = (T)3.1415926;
- 其他形式的变量模板

C++14 引入了变量模板（Variable Templates）的概念，它允许你定义参数化的变量，类似于函数模板允许你定义参数化的函数。变量模板提供了一种通用的方式来定义与类型相关的常量或变量，使得代码更具有通用性和灵活性。

lambda模板表达式

// 使用 C++20 中的 lambda 模板
    auto genericLambda = []<typename T>(T x, T y) {
        return x + y;
    };

练习

#include <type_traits>
#include <iostream>
#include <vector>
#include <initializer_list>

template<typename T>
struct get_type{
    using type=T;
};

template<typename T>
struct get_type<T*>{
    using type=T;
};

template<typename T>
class myArray{
    using iterator=T*;
    using const_iterator=const T*;
public:
    myArray(size_t count);
    ~myArray();
    myArray(const std::initializer_list<T>& list);
    myArray(std::initializer_list<T>& list);


    iterator begin(){
        return _data;
    }
    const_iterator cbegin()const{
        return _data;
    }
private:
    T* _data;
};

template<typename T>
myArray<T>::myArray(size_t count) {
    if(count){
        _data=new T[count];
    }
    else{
        _data= nullptr;
    }
}

template<typename T>
myArray<T>::~myArray() {
    if (_data) {
        delete[] _data;
    }
}

template<typename T>
myArray<T>::myArray(const std::initializer_list<T>& list){
    if(int count=0;list.size()){
        _data=new T[list.size()]();
        if constexpr (std::is_pointer_v<T>){  //萃取 如果是指针就要深拷贝
            for(auto e:list)
              _data[count++]=new typename get_type<T>::type(*e);
        }
        else{
            for(const auto& e:list){
                _data[count++]=e;
            }
        }
    }
    else{
        _data= nullptr;
    }
}