c++函数模板

已于 2023-08-24 19:33:20 修改
阅读量1k 收藏 4
点赞数 1
分类专栏： C++ 学习 文章标签： c++ 开发语言 算法
于 2023-08-23 22:53:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012011912/article/details/132456238
版权

一、 函数模板基本概念

C++函数模板是一种可以在代码中定义通用函数的方式，其可以用于定义可以接受任意类型的参数的函数。通过使用函数模板，程序员可以避免重复编写相似的代码，提高代码的可重用性和可维护性。

1.1 定义函数模板的语法

template <typename T>
T func_name(T arg1, T arg2, ...)
{
    // 函数体
}
  • template关键字表示接下来的代码是一个函数模板的定义
  • typename表示模板参数的类型
  • T是一种类型参数的通用名字
  • func_name即函数模板的名称。

在 C++98 添加关键字 typename 之前，C++使用关键字 class 来创建模板。
函数模板中的参数列表可以是任意数量的、任意类型的参数。在函数模板中，可以使用模板参数来表示参数的类型、函数返回值的类型等。

1.2 实现函数模板

函数模板的实现可以在代码文件中或头文件中完成。建议将函数模板的实现放在头文件中，以便其他代码可以直接使用。

template <typename T>
T max(T a, T b)
{
    return a > b ? a : b;
}

上述代码实现了一个可以接受任意类型的函数模板max，其返回两个参数中的最大值。

使用函数模板时，用指定的类型替换函数模板中的模板参数即可。例如，以下代码使用函数模板max来查找两个整数中的最大值：

int x = 10, y = 20;
int max_val = max(x, y);  // 使用函数模板max查找两个整数中的最大值

double a=10.0,b=20.0;
double max_val1 = max(a,b);

函数模板实例化可以让编译器自动推导，也可以在调用的代码中显式的指定。

int x = 10, y = 20;
int max_val<int> = max(x, y);  // 使用函数模板max查找两个整数中的最大值

double a=10.0,b=20.0;
double max_val1<double> = max(a,b);

二、函数模板注意事项

  1. 可以为类的成员函数创建模板，但不能是虚函数和析构函数

    class MyClass{
public:
    template<typename T>
    MyClass(T a){//构造函数可以使用函数模板
        cout<<a<<endl;
    }
    template<typename T>
    void fun(T b){//普通函数可以使用函数模板
        cout<<b<<endl;
    }
//    template<typename T>虚函数不可以用于函数模板：virtual' cannot be specified on member function templates
//    virtual void fun1(T c){
//        cout<<c<<endl;
//    }

	//析构函数不用函数模板，因为析构函数没有参数
};
int main() {
    MyClass m(3);//3
    m.fun(4);//4
}

  2. 在使用函数模板时，必须明确指定数据类型，以确保实参与函数模板参数匹配

    //比如，我们定义了一个函数模板，用于计算两个数的和。函数模板的定义如下：
template <typename T>
T add(T a, T b)
{
    return a + b;
}
//如果我们想要计算两个整数的和，可以这样调用函数：
int a = 1, b = 2;
int c = add<int>(a, b);
//或者int c = add(a, b);
//这里，我们明确指定了数据类型为 int，保证了实参与函数模板能匹配上。如果我们这样调用函数：
int a = 1;
double b = 2.0;
double c = add<double>(a, b);
//这里，我们指定了数据类型为 double，但是实参 a 的数据类型为 int，与函数模板的数据类型不匹配，会出现编译错误。

  3. 使用函数模板时，推导的数据类型必须适应函数模板中的代码

    template <typename T>
T fun(T a,T b) {//函数中的代码，不适用MyClass类型
    return a+b;
}

class MyClass{};

int main() {
    int a=1,b=2;
    int c=fun(a,b);

    double x=1.0,y=2.0;
    double z= fun(x,y);
//    MyClass aa,bb;
//    MyClass cc = fun(aa,bb);
}

  4. 在使用自动类型推导时，函数模板不会发生隐式类型转换

    template <typename T>
T Add(T a, T b) {
    return a + b;
}

int main() {
    int sum = Add(5, 3.2); // 错误：隐式类型转换不适用于自动类型推导
    double total = Add<double>(5, 3.2); // 正确：显式指定数据类型进行隐式类型转换
    return 0;
}

  5. 函数模板可以支持多个通用数据类型的参数

    template <typename T1,typename T2>
void fun(T1 a, T2 b) {
    cout<<a<<endl;
    cout<<b<<endl;
}

int main() {
    fun(3,"123");
}

  6. 函数模板支持重载，其中可以包含非通用数据类型的参数

    void fun(int a){
    cout<<"void fun(int a)"<<endl;
}

template <typename T>
void fun(T a) {
    cout<<"fun(T a)"<<endl;
}

template <typename T1,typename T2>
void fun(T1 a,T2 b) {
    cout<<"void fun(T1 a,T2 b)"<<endl;
}

template <typename T1,typename T2>
void fun(T1 a,T2 b,int c) {
    cout<<"void fun(T1 a,T2 b,int c)"<<endl;
}

int main() {
    fun(3);//void fun(int a)
    fun(1.2);//fun(T a)
    fun(1.2,3);//void fun(T1 a,T2 b)
    fun(1.2,3,3);//void fun(T1 a,T2 b,int c)
}

三、函数模板的具体化

函数模板是一种通用的函数定义，可以用来创建适用于多种数据类型的函数。然而，有时候我们需要针对特定的数据类型提供更特定的实现，这就引入了函数模板的具体化（也叫特化）概念。具体化允许我们为特定的数据类型提供专门的函数实现，以优先于通用的函数模板或普通函数。
下面是具体化的语法示例：

template<> 
void 函数模板名<数据类型>(参数列表)
{
    // 函数体。
}

或者简化写法：

template<> 
void 函数模板名 (参数列表)
{
    // 函数体。
}

对于给定的函数名，可以有普通函数、函数模板和具体化的函数模板，以及它们的重载版本。

3.1编译器使用各种函数的规则

  1. 具体化优先于常规模板，普通函数优先于具体化和常规模板。

    • 普通函数优先于具体化和常规模板

      void fun(int a){
    cout<<"普通函数：void fun(int a)"<<endl;
}

template <typename T>
void fun(T a) {
    cout<<"函数模板：fun(T a)"<<endl;
}
template<>
void fun<int>(int a){
    cout<<"函数模板的具体化：void fun<int>(int a)"<<endl;
}

int main() {
    fun(3);//普通函数：void fun(int a)
}

    • 具体化优先于常规模板

      template <typename T>
void fun(T a) {
    cout<<"函数模板：fun(T a)"<<endl;
}
template<>
void fun<int>(int a){
    cout<<"函数的具体化：void fun<int>(int a)"<<endl;
}

int main() {
    fun(3);//函数模板的具体化：void fun<int>(int a)
}

  2. 如果不希望使用普通函数，希望使用函数模板，可以用空模板参数强制使用函数模板。

    void fun(int a) {
    cout<<"普通函数：void fun(int a)"<<endl;
}
template <typename T>
void fun(T a) {
    cout<<"函数模板：fun(T a)"<<endl;
}

int main() {
    fun<>(3);//函数模板：fun(T a)
}

    void fun(int a) {
    cout<<"普通函数：void fun(int a)"<<endl;
}
template <typename T>
void fun(T a) {
    cout<<"函数模板：fun(T a)"<<endl;
}
template<>
void fun<int>(int a){
    cout<<"函数的具体化：void fun<int>(int a)"<<endl;
}

int main() {
    fun<>(3);//函数的具体化：void fun<int>(int a)
}

  3. 如果函数模板能产生更好的匹配，将优先于普通函数

    void fun(int a) {
    cout<<"普通函数：void fun(int a)"<<endl;
}
template <typename T>
void fun(T a) {
    cout<<"函数模板：fun(T a)"<<endl;
}

template <>
void fun(int a) {
    cout<<"函数模板：fun(T a)"<<endl;
}

int main() {
    fun('a');//函数模板：fun(T a)
}

四、普通函数、函数模板和函数模板具体化详解

4.1 普通函数与函数模板的区别

  • 普通函数调用时可以发生自动类型转换（隐式类型转换）

    void fun(int a, int b) {
    cout<<a+b<<endl;
}

int main() {
    int a=10;
    double b=20.0;
    char c='A';
    fun(a,a);
    fun(a,b);//将double隐式转换成int
    fun(a,c);//将char隐式转换成int
}

  • 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换

    template<typename T>
void fun(T a,T b){
    cout<<a+b<<endl;
}

int main() {
    int a=10;
    double b=20.0;
    char c='A';
    fun(a,a);
    fun(a,b);//报错：使用自动类型推导，不会发生隐式类型转换
    fun(a,c);//报错：使用自动类型推导，不会发生隐式类型转换
}

  • 如果利用显示指定类型的方式，可以发生隐式类型转换

    template<typename T>
void fun(T a,T b){
    cout<<a+b<<endl;
}

int main() {
    int a=10;
    double b=20.0;
    char c='A';
    fun(a,a);
    fun<int>(a,b);//如果用显示指定类型，可以发生隐式类型转换
    fun<int>(a,c);//如果用显示指定类型，可以发生隐式类型转换
}

总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

4.2普通函数与函数模板的调用规则

  • 如果函数模板和普通函数都可以实现，优先调用普通函数

    void fun(int a,int b){
    cout<<"普通函数：void fun(int a,int b)"<<endl;
}

template<typename T>
void fun(T a,T b){
    cout<<"函数模板：void fun(T a,T b)"<<endl;
}

int main() {
    fun(1,2);//普通函数：void fun(int a,int b)
}

  • 可以通过空模板参数列表来强制调用函数模板

    void fun(int a,int b){
    cout<<"普通函数：void fun(int a,int b)"<<endl;
}

template<typename T>
void fun(T a,T b){
    cout<<"函数模板：void fun(T a,T b)"<<endl;
}

int main() {
	//可以通过空模板参数列表来强制调用函数模板
    fun<>(1,2);//函数模板：void fun(T a,T b)
}

  • 函数模板也可以发生重载

    template<typename T>
void fun(T a,T b){
    cout<<"函数模板：void fun(T a,T b)"<<endl;
}
template<typename T>
void fun(T a,T b,T c){
    cout<<"函数模板：void fun(T a,T b,T c)"<<endl;
}

int main() {
    fun<>(1,2);//函数模板：void fun(T a,T b)
    fun<>(1,2,3);//函数模板：void fun(T a,T b,T c)
}

  • 如果函数模板可以产生更好的匹配,优先调用函数模板(和第三节一样的)

总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

4.3 函数模板的局限性

模板的通用性并不是万能的
例如：

template<class T>
void f(T a, T b)
{ 
    a = b;
}

在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了
再例如：

template<class T>
void f(T a, T b)
{ 
    if(a > b) { ... }
}

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行
因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

class Dog{
public:
    Dog(string name,int age):name_(name),age_(age){
    }
    string name_;
    int age_;
};

//普通函数模板
template<typename T>
bool compare(T &a,T &b){
    if(a==b)return true;
    return false;
}

//如果要比较两个对象是否相等，就不能只想上面直接判断传入的两个对象相等来判断了
//第一种解决方案：重载Dog类里面的==运算符，稍微有点麻烦
//第二种解决方案：使用函数模板的具体化
template<>
bool compare(Dog &a,Dog &b){
    if((a.age_==b.age_)&&(a.name_==b.name_))return true;
    return false;
}

int main(){
    int a=1,b=2;
    bool result1 = compare(a,b);//调用通用函数模板
    cout<<result1<<endl;//false

    Dog dog1("哈士奇",3);
    Dog dog2("哈士奇",3);
    bool result2= compare(dog1,dog2);//调用函数模板具体化
    cout<<result2<<endl;//true
}

五、函数模板分文件编写

5.1 实体是什么

在函数模板的上下文中，"实体"指的是根据函数模板的描述生成的实际函数代码，也就是特定类型或参数的具体函数。
举例来说，如果有一个函数模板用于交换两个值的函数：

template <typename T>
void swapValues(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

在这个例子中，swapValues 函数模板的实体是在实际调用时根据提供的类型（例如 int、double、string 等）生成的函数。所以当你在代码中调用 swapValues 函数模板时，编译器会根据提供的类型生成对应的实体函数。
实体函数是编译器最终生成的、可以被机器执行的代码。在 C++ 中，函数模板的实体是根据模板参数具体化生成的。实体函数才是真正被程序调用和执行的部分。

5.2 函数模板份文件编写原则：

  • 函数模板只是函数的描述，没有实体，创建函数模板的代码放在头文件中。
  • 函数模板的具体化有实体，编译的原理和普通函数一样，所以，声明放在头文件中，定义放在源文件中。
  1. 普通函数：
    • test.h
      #include<iostream>
using namespace std;
void fun(int a);//普通函数声明在头文件
    • test.cpp
      include"test.h"
void fun(int a){//普通用函数定义在源文件
    cout<<a<<endl;
}
    • main.cpp
      #include "test.h"
int main(){
    fun(3);//3
}
  2. 函数模板和函数模板具体化
    • test.h
      #include<iostream>
using namespace std;

template<typename T>//函数模板的创建写在头文件中
void fun(T a){
    cout<<a<<endl;
}

template<>//函数模板的具体化的声明写在头文件中
void fun(int a);
    • test.cpp
      #include "test.h"

template<>//函数模板的具体化的定义写在头文件中
void fun(int a){
    cout<<a<<endl;
}
    • main.cpp
      #include "test.h"
int main(){
    fun(3);//3
}
海绵宝宝丶哈
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++函数模板
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-09 652
函数模板 C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板 C++提供两种模板机制:函数模板和类模板 1.2.1 函数模板语法 函数模板作用： 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。 语法： template<typename T> 函数声明或定义 解释： template — 声明创建模板 typename — 表面其后面的符号是一种数据类型，可以用class代替 T — 通用的数据类型，名称可以替换，通常
C++学习心得第三期 模板
qq_37448336的博客
10-13 292
C++学习心得第三期 模板一、函数模板1.1 语法1.2 函数模板注意事项1.3 函数模板案例1.4普通函数与函数模板的区别1.5普通函数与函数模板的调用规则二、使用步骤1.引入库2.读入数据 一、函数模板 1.1 语法 函数模板作用： 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。 语法： template 函数声明或定义 解释： template — 声明创建模板 typename — 表面其后面的符号是一种数据类型，可以用class代替 T — 通用的数据类
C++中的模板
最新发布
2302_81171591的博客
07-22 861
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链 接起来形成单一的可执行文件的过程称为分离编译模式。return 0;编译器报错解决方案1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的，推荐使用这种//a.h。
C++函数模板与类模板实例解析
01-20
本文针对C++函数模板与类模板进行了较为详尽的实例解析，有助于帮助读者加深对C++函数模板与类模板的理解。具体内容如下： 泛型编程（Generic Programming）是一种编程范式，通过将类型参数化来实现在同一份代码上...
详解C++函数模板与分离编译模式
01-19
1.分离编译模式 ...下面的程序由三个文件组成：func.h用来对函数模板进行申明，func.cpp用来定义函数模板，main.cpp包含func.h头文件并调用相应的函数模板。 /***func.h***/ template<class> void
C++中的函数模板
Littlehero_121的博客
01-21 359
觉得大神写的很好，就摘抄下来了，有需要可以查看原版链接，如下： 以下内容是摘抄博客：C++中的函数模板_年少轻狂，幸福时光-CSDN博客_函数模板 之前我们知道的交换两个变量的方法有宏定义、函数，这两种方式都能实现两个变量的交换，但是各有各的优缺点 宏定义： - 优点：代码复用，适合所有的类型 - 缺点：缺少类型检查，宏在预处理阶段就被替换掉，编译器并不知道宏的存在 函数： - 优点：真正的函数调用，编译器对类型进行检查 - 缺点：类型不同需要重复定...
C++模板之函数模板
qq_44643681的博客
08-14 830
记录C++的成长之路
c++ 函数模板
若尘的博客
06-12 1876
c++ obj文件 obj文件就是目标文件，是源程序经过编译程序编译后生成的 不能直接执行，需要连接程序连接后才能生成可执行文件，这样就能执行 一般由机器代码组成，但也可以是自己定义的一些伪指令代码（需有专门的解释程序对其进行解释执行） 连接程序 把目标代码和它所使用的库文件连接的程序 obj文件与exe文件的区别 编译：当前源代码编译成二进制目标文件(obj文件) 链接(link): ...
C++模板函数
热门推荐
weixin_45738899的博客
12-06 2万+
模板函数与类模板1.模板函数1.模板函数的声明与定义2.模板函数的调用显式类型调用自动推导3.模板函数的底层实现 1.模板函数 1.模板函数的声明与定义 C++提供了模板(template)编程的概念。所谓模板，实际上是建立一个通用函数或类，其类内部的类型和函数的形参类型不具体指定，用一个虚拟的类型来代表。这种通用的方式称为模板。模板是泛型编程的基础,泛型编程即以一种独立于任何特定类型的方式编写代码。 简单来说，就是我们提供一个抽象的函数，并不具体指定其中数据的类型，而是某个虚拟类型代替。只提供基本的功
【C++】C++函数模板介绍及使用案例
qq_35902025的博客
10-11 3122
函数模板的作用建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，不用为每一个类型定义新的函数。函数模板与函数重载函数重载：同一个函数名，不同类型参数，每个函数都需要具体实现出来。函数模板：只需要实现一个函数，也可以实现函数重载同样的功能。区别：函数重载函数体中的具体功能可以不同，更加灵活；对于同一功能，参数类型不同，二者作用一样。函数模板的定义//函数声明或定义，下面紧跟着对应的函数//括号中为模板参数列表，模板定义中，模板参数列表不能为空。template ：声明创建模板的关键字。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值