C++函数模板

最新推荐文章于 2025-07-24 20:33:53 发布
原创 最新推荐文章于 2025-07-24 20:33:53 发布 · 333 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言 #学习

本文深入探讨C++中的函数模板应用，包括基本语法、注意事项及如何处理不同类型数据的排序操作。同时，文章还讨论了普通函数与函数模板的区别，并介绍了模板在特定情况下的局限性和解决方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 

 

 

 普通实现

#include <iostream>
#include <string>
#include <fstream>

using namespace std;
//函数模板


//交换两个整型交换函数
void swapInt(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

//交换两个浮点型函数
void swapDouble(double &a, double &b) {
    double temp = a;
    a = b;
    b = temp;
}

void test() {
    int a = 10;
    int b = 20;
    swapInt(a, b);
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;

    double c = 10.2;
    double d = 20;
    swapDouble(c, d);
    cout << "c=" << c << endl;
    cout << "d=" << d << endl;
}

int main() {
    test();
    return 0;
}

模板实现

#include <iostream>
#include <string>
#include <fstream>

using namespace std;
//函数模板


//交换两个整型交换函数
void swapInt(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

//交换两个浮点型函数
void swapDouble(double &a, double &b) {
    double temp = a;
    a = b;
    b = temp;
}

//函数模板
template<typename T>
//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型

void mySwap(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}


void test() {
    int a = 10;
    int b = 20;
    swapInt(a, b);
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;

    double c = 10.2;
    double d = 20;
    swapDouble(c, d);
    cout << "c=" << c << endl;
    cout << "d=" << d << endl;
}

void test2() {
    //使用函数模板有两种方式
    int a = 10;
    int b = 20;
    //1 自动类型推到
    mySwap(a, b);
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;

    //2 显示指定类型
    double c = 10.2;
    double d = 20.3;
    mySwap<double>(c, d);
    cout << "c=" << c << endl;
    cout << "d=" << d << endl;

}

int main() {
//    test();
    test2();
    return 0;
}

 函数模板注意事项如下

#include <iostream>
#include <string>
#include <fstream>

using namespace std;
//函数模板注意是想
/*
 * 1 自动类型推到  必须推导出一致的数据类型T才可以使用
 *
 * 2 模板必须要确定出T的数据类型，才可以使用
 *
 */

//typename 可以替换成class
template<class T>

void mySwap(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

//1 自动类型推到  必须推导出一致的数据类型T才可以使用
void test() {
    int a = 10;
    int b = 20;
    mySwap(a, b);//正确

    char c = 'a';
//    mySwap(a, c);//错误；必须推导出一致的数据类型T才可以使用
}

//template<typename T>//如果是注释的，test2是可以调用func();的
template<typename T>//如果是没注释的，test2是不可以调用func();的，因为模板必须没有确定出T的数据类型，需要显示指定类型调用  func<int>();
void func() {
    cout << "func 调用" << endl;
}

void test2() {
//    func();
    func<int>();
}
int main() {
//    test();
    test2();
    return 0;
}

函数模板案例-数组排序

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

/*
 *实现通用 对数组进行排序的函数
 * 规则 从大到小
 * 算法 选择排序
 * 测试 char 数组、int 数组
 */
//交换函数模板
template<typename T>
void mySwap(T &a, T &b) {
    int temp = a;
    a = b;
    b = temp;
}

//排序算法
template<typename T>
void mySort(T arr[], int len) {
    for (int i = 0; i < len; i++) {
        int max = i;
        for (int j = i + 1; j < len; j++) {
            if (arr[max] < arr[j]) {
                max = j;

            }
        }
        if (max != i) {
            mySwap(arr[max], arr[i]);
        }
    }
}

//提供打印数组的模板
template<typename T>
void printArray(T arr[], int len) {
    for (int i = 0; i < len; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

void test() {
    //测试char数组
    char charArr[] = "badcfe";
    int num = sizeof(charArr) / sizeof(char);
    mySort(charArr, num);
    printArray(charArr, num);
}

void test2() {
    int arr[] = {32, 321, 3, 4324, 2, 543, 5, 46, 1};
    int num = sizeof(arr) / sizeof(int);
    mySort(arr,num);
    printArray(arr, num);
}

int main() {
    test();
    test2();
    return 0;
}

 

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

/*
 *学习普通函数与函数模板的区别
 * 1 普通函数调用可以发生隐式类型转换
 * 2 函数模板 用自动类型推导，不可以发生隐式类型转换
 * 3 函数模板 用显示指定类型，可以发生隐式类型转换
 */

//普通函数

int myAdd(int a, int b) {
    return a + b;
}

//函数模板
template<typename T>
T myAdd2(T a, T b) {
    return a + b;
}

void test() {
    int a = 10;
    int b = 20;
    cout << myAdd(a, b) << endl;
    char c = 'c';
    cout << myAdd(a, c) << endl;//发生隐式转换
    double d = 10.2;
    cout << myAdd(a, d) << endl;//发生隐式转换

    //自动类型推导
//    myAdd2(a, c);//报错，自动推导不会发生隐式类型转换
    myAdd2<int>(a, c);//不报错，显示指定类型会发生隐式类型转换

}

int main() {
    test();
    return 0;
}

 

 调用普通函数

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

/*
 *普通函数与函数模板掉好用规则
 * 1  如果函数模板和普通函数可以调用，优先调用普通函数
 * 2 可以通过空模板参数列表，强制调用 函数模板
 * 3 函数模板可以发生函数重载
 * 4 如果函数模板可以产生更好的匹配 优先调用函数模板
 */

void myPrint(int a, int b) {
    cout << "调用普通函数" << endl;
}

template<class T>
void myPrint(T a, T b) {
    cout << "调用函数模板" << endl;
}

void test() {
    int a = 10;
    int b = 20;
    myPrint(a, b);
}

int main() {
    test();
    return 0;
}

报错 ，普通函数只有声明没有实现

#include <iostream>
#include <string>
#include <fstream>
using namespace std;

/*
 *普通函数与函数模板掉好用规则
 * 1  如果函数模板和普通函数可以调用，优先调用普通函数
 * 2 可以通过空模板参数列表，强制调用 函数模板
 * 3 函数模板可以发生函数重载
 * 4 如果函数模板可以产生更好的匹配 优先调用函数模板
 */

void myPrint(int a, int b);

template<class T>
void myPrint(T a, T b) {
    cout << "调用函数模板" << endl;
}

void test() {
    int a = 10;
    int b = 20;
    myPrint(a, b);
}

int main() {
    test();
    return 0;
}
Undefined symbols for architecture x86_64:
  "myPrint(int, int)", referenced from:
      test() in main.cpp.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make[3]: *** [first_demo] Error 1
make[2]: *** [CMakeFiles/first_demo.dir/all] Error 2
make[1]: *** [CMakeFiles/first_demo.dir/rule] Error 2
make: *** [first_demo] Error 2

通过空模板参数列表，强制调用函数模板

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

/*
 *普通函数与函数模板掉好用规则
 * 1  如果函数模板和普通函数可以调用，优先调用普通函数
 * 2 可以通过空模板参数列表，强制调用 函数模板
 * 3 函数模板可以发生函数重载
 * 4 如果函数模板可以产生更好的匹配 优先调用函数模板
 */

void myPrint(int a, int b);

template<class T>
void myPrint(T a, T b) {
    cout << "调用函数模板" << endl;
}

void test() {
    int a = 10;
    int b = 20;
//    myPrint(a, b);

    //通过空模板参数列表，强制调用函数模板
    myPrint<>(a, b);
}

int main() {
    test();
    return 0;
}

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

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

/*
 *普通函数与函数模板掉好用规则
 * 1  如果函数模板和普通函数可以调用，优先调用普通函数
 * 2 可以通过空模板参数列表，强制调用 函数模板
 * 3 函数模板可以发生函数重载
 * 4 如果函数模板可以产生更好的匹配 优先调用函数模板
 */

void myPrint(int a, int b);

template<class T>
void myPrint(T a, T b) {
    cout << "2个参数 调用函数模板" << endl;
}

template<class T>
void myPrint(T a, T b, T c) {
    cout << "3个参数 调用函数模板" << endl;
}

void test() {
    int a = 10;
    int b = 20;
//    myPrint(a, b);

    //通过空模板参数列表，强制调用函数模板
    myPrint<>(a, b);
    myPrint<>(a, b, 30);
}

int main() {
    test();
    return 0;
}

如果函数模板可以产生更好的匹配 优先调用函数模板

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

/*
 *普通函数与函数模板掉好用规则
 * 1  如果函数模板和普通函数可以调用，优先调用普通函数
 * 2 可以通过空模板参数列表，强制调用 函数模板
 * 3 函数模板可以发生函数重载
 * 4 如果函数模板可以产生更好的匹配 优先调用函数模板
 */

void myPrint(int a, int b) {
    cout << "调用普通函数" << endl;
}

template<class T>
void myPrint(T a, T b) {
    cout << "2个参数 调用函数模板" << endl;
}

template<class T>
void myPrint(T a, T b, T c) {
    cout << "3个参数 调用函数模板" << endl;
}

void test() {
    int a = 10;
    int b = 20;
//    myPrint(a, b);

    //通过空模板参数列表，强制调用函数模板
//    myPrint<>(a, b);
//    myPrint<>(a, b, 30);

    //如果函数模板可以产生更好的匹配 优先调用函数模板,这里编译器觉得发生隐式转换还不如自动类型推导   
    char c1 = 'a';
    char c2 = 'b';
    myPrint(c1, c2);
}

int main() {
    test();
    return 0;
}

 

模板的局限性

1、正常实现，没问题

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

/*
 * 模板的局限性
 *  模板并不是万能的，有些特定数据类型，徐亚用具体化方式做特殊实现
 *
 */

template<typename T>
bool myCompare(T &a, T &b) {
    return a == b;
}

void test() {
    int i = 0;
    int j = 1;
    bool b = myCompare(i, j);
    if (b) {
        cout << "相等" << endl;
    } else {
        cout << "不相等" << endl;
    }
}

int main() {
    test();
    return 0;
}

2、 自定义实现，有问题

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

/*
 * 模板的局限性
 *  模板并不是万能的，有些特定数据类型，徐亚用具体化方式做特殊实现
 *
 */

class Person {
public:
    Person(int a, string n) {
        age = a;
        name = n;
    }

    int age;
    string name;


};

template<typename T>
bool myCompare(T &a, T &b) {
    return a == b;
}

void test() {
    int i = 0;
    int j = 1;
    bool b = myCompare(i, j);
    if (b) {
        cout << "相等" << endl;
    } else {
        cout << "不相等" << endl;
    }
}

void test2() {
    Person p1(1, "Tom");
    Person p2(1, "Tom");
    bool b = myCompare(p1, p2);
    if (b) {
        cout << "相等" << endl;
    } else {
        cout << "不相等" << endl;
    }
}

int main() {
//    test();
    test2();
    return 0;
}

报错了

bool myCompare(T &a, T &b) {
    return a == b;//Invalid operands to binary expression ('Person' and 'Person')
}

解决办法

1 重载==运算符，不过太麻烦了，要是有>或者

2 利用具体化的Person的版本实现代码，具体优化优先调用

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

/*
 * 模板的局限性
 *  模板并不是万能的，有些特定数据类型，徐亚用具体化方式做特殊实现
 *
 */

class Person {
public:
    Person(int a, string n) {
        age = a;
        name = n;
    }

    int age;
    string name;


};

template<typename T>
bool myCompare(T &a, T &b) {
    return a == b;
}

//利用具体化的Person的版本实现代码，具体优化优先调用  (格式化后就换行了)
template<>
bool myCompare(Person &p1, Person &p2) {
    if (p1.age == p2.age && p1.name == p2.name) {
        return true;
    }
    return false;
}

void test() {
    int i = 0;
    int j = 1;
    bool b = myCompare(i, j);
    if (b) {
        cout << "相等" << endl;
    } else {
        cout << "不相等" << endl;
    }
}

void test2() {
    Person p1(1, "Tom");
    Person p2(1, "Tom");
    bool b = myCompare(p1, p2);
    if (b) {
        cout << "相等" << endl;
    } else {
        cout << "不相等" << endl;
    }
}

int main() {
//    test();
    test2();
    return 0;
}

 

C++报错 invalid operands to binary expression
ken2232的博客
08-05 1万+
C++报错 invalid operands to binary expression
invalid operands to binary expression 二进制表达式的无效操作数
想要上南大的同学的博客
12-30 7066
invalid operands to binary expression 二进制表达式的无效操作数 顾名思义 错误出在操作符上 对类型的操作问题 比如两种不能比较的类型进行了比较
gcc编译出现：error: invalid operands to binary & (have ‘char *’ and ‘int *’)
weixin_33711641的博客
06-03 2万+
1 /************************************************************************* 2 > File Name: ptr_variable.c 3 > Author: Mr.Yang 4 > Purpose:演示指向变量的指针 5 > Created...
解决“invalid operands to binary & (have ‘float‘ and ‘int‘)”错误的方法
OMGMac的博客
02-23 3万+
今天继续来分享一个自己今天遇到的错误，错误提示信息：“invalid operands to binary & (have ‘float’ and ‘int’)” ，可能有些小伙伴可能会问，为什么不能对浮点数进行&呢？因为浮点数与整形不一样，不能直接进行位运算。
报错invalid operands to binary expression (const char * and const char[9])
weixin_44074560的博客
07-18 5708
报错invalid operands to binary expression (const char * and const char[9])
C++函数模板与类模板实例解析
01-20
本文针对C++函数模板与类模板进行了较为详尽的实例解析，有助于帮助读者加深对C++函数模板与类模板的理解。具体内容如下： 泛型编程（Generic Programming）是一种编程范式，通过将类型参数化来实现在同一份代码上...
c++函数模板
02-16
其中，template为关键字，表示定义一个模板（可以是函数模板或类模板），尖括号表示模板参数，模板类型参数使用关键字class或typename开始，其后是一个用户定义的合法的标识符。 如果用户在调用函数模板时显式标识...
详解C++函数模板与分离编译模式
01-19
1.分离编译模式 ...下面的程序由三个文件组成：func.h用来对函数模板进行申明，func.cpp用来定义函数模板，main.cpp包含func.h头文件并调用相应的函数模板。 /***func.h***/ template<class> void
C++函数模板详解及其应用：提升代码复用性的关键技术
03-25
内容概要：本文详细介绍了C++函数模板的基础概念、实现机制以及其实战应用。文章从常见的代码重复问题引出函数模板的需求，讲述了函数模板的定义语法与基本用法，包括模板实例化、模板实参推演的规则，并探讨了一些...
gcc编译出现 invalid operands to binary -的解决方法
07-26 2万+
在做pcap库抓包的程序中，使用了： pcap_head->caplen - (unsigned int)(/*(unsigned char *)*/data - packet); 算式，然后就报“ invalid operands to binary -”。 检查代码，其中packet为char *型，pcap_loop的回调函数的第三个参数，data为根据各层字节计算出的TCP首部位置；但是
Invalid operands to binary expression ('double' and 'double’)
onebutterfly
01-09 3万+
Invalid operands to binary expression (‘double’ and ‘double’)在下面的代码中，实现功能是获取estimatedProgress是5的倍数的值做些操作， double estimatedProgress = 100; if(estimatedProgress%5==0) {——错误出现行 NSLog(@"");
ERROR:invalid operands to binary -
热门推荐
zoudaokou2006的专栏
03-26 3万+
ERROR:invalid operands to binary - (二元减法运算的操作数无效。)代码如下：...typedef PACKED struct{ unsigned char chg_rule[MMIPT_MAX_CHG_RULE_LIST]; ...}MMIPT_CHG_RULE_T;void Example(...){
请问C/C++中编译过程出现 error: invalid operands to binary & (have 'char *' and 'float')怎么解决，谢谢
weixin_45690610的博客
03-15 1万+
欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作...
c++--面向对象封装--实践
weixin_63164319的博客
07-23 1134
单参构造函数：参数为 const char*，支持隐式类型转换（如 mystring str = "hello";列表初始化：len(strlen(s)) 在对象构造前初始化 len，比在函数体中赋值更高效。// 输出：你好world你好。计算新长度 len + other.len（或 len + strlen(s)）。// 复制 "world"str.append(ptr);// 追加 "world"str.copy("你好");// 复制 "你好"str.append("你好");// 追加 "你好"
C语言（十）
最新发布
2302_80202237的博客
07-24 400
函数是面向过程编程思想的具体体现，主要作用：降低程序之间的耦合性提高代码的复用性和可维护性一个完整的 C 程序由**一个或多个程序模块（源文件）**组成。为便于开发与调试，通常会将代码拆分为多个源文件，并组合成一个整体程序。每个源文件是一个编译单位，即 C 编译器以“源文件”为单位进行编译。程序从main()函数开始执行，调用其他函数后，执行完再返回到main()，最终在main()结束程序运行。用户根据需要自定义提高模块化和代码复用能力。
C++视觉算法实战指南
keny-大成的博客
07-23 837
本文介绍了C++在计算机视觉领域的常用算法实现，涵盖OpenCV图像处理、PCL点云处理和OpenCV DNN模块三大方向。主要内容包括：1. OpenCV基础：图像滤波、边缘检测、特征匹配等传统算法实现；2. PCL点云处理：滤波、分割、配准、特征提取等点云操作方法；3. OpenCV DNN模块：YOLO、ResNet等深度学习模型的部署应用。文章提供了大量可直接运行的代码示例，适合开发者快速实现各类视觉任务，同时强调了算法选择和性能优化的注意事项。
C++函数模板详解：问题、解决与应用
C++函数模板是一种强大的特性，它允许程序员为一组相似的函数编写通用代码，无需为每种类型单独编写函数实例。本资源详细介绍了C++函数模板的工作原理、存在的问题以及解决方案。 首先，C++作为强类型语言，要求...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值