C++重载和模板

news2024/10/6 16:23:52

重载与模板

函数模板可以被另一个模板或一个普通非模板函数重载。

与往常一样,名字相同的函数必须具有不同数量或类型的参数。

如果涉及函数模板,则函数匹配规则会在以下几方面受到影响:

  1. 对于一个调用,其候选函数包括所有模板实参推断成功的函数模板实例。
  2. 候选的函数模板总是可行的,因为模板实参推断会排除任何不可行的模板。
  3. 与往常一样,可行函数(模板与非模板)按类型转换(如果对此调用需要的话)来排序。当然,可以用于函数模板调用的类型转换是非常有限的。
  4. 与往常一样,如果恰有一个函数提供比任何其他函数都更好的匹配,则选择此函数。但是,如果有多个函数提供同样好的匹配,则:

              ——如果同样好的函数中只有一个是非模板函数,则选择此函数,

               ——如果同样好的函数中没有非模板函数,而有多个函数模板,且其中一个模板比其他                          模板更特例化,则选择此模板。

               ——否则,此调用有歧义。

正确定义一组重载的函数模板需要对类型间的关系及模板函数允许的有限的实参类型转换有深刻的理解。

编写重载模板

作为一个例子,我们将构造一组函数,它们在调试中可能很有用。

我们将这些调试函数命名为debug_rep,每个函数都返回一个给定对象的string表示。

我们首先编写此函数的最通用版本,将它定义为一个模板,接受一个const对象的引用:

//打印任何我们不能处理的类型
template <typename T> 
string debug_rep(const T& t)
{
	ostringstream ret;
	ret << t; // 使用T的输出运算符打印t的一个表示形式
		return ret.str();// 返回ret 绑定的string的一个副本
}

此函数可以用来生成一个对象对应的string表示,该对象可以是任意具备输出运算符的类型。

接下来,我们将定义打印指针的debug_rep版本:


template <typename T> 
string debug_rep(T* p)
{
	cout << "使用了T*p版本" << endl;
	ostringstream ret;  // 打印指针本身的值
	ret << "pointer: " << p;
		if (p)
			ret << "" << debug_rep(*p);// 打印p指向的值
		else
			ret << " null pointer"; // 或指出ρ为空
			return ret.str();// 返回ret 绑定的string的一个副本
}

此版本生成一个string,包含指针本身的值和调用debug_rep获得的指针指向的值。

注意此函数不能用于打印字符指针,因为IO库为char+值定义了一个<<版本。此<版本假定指针表示一个空字符结尾的字符数组,并打印数组的内容而非地址值。

我们可以这样使用这些函数:

#include<iostream>
#include<sstream>
using namespace std;
//打印任何我们不能处理的类型
template <typename T> 
string debug_rep(const T& t)
{
	cout << "使用了const T&t版本" << endl;
	ostringstream ret;
	ret << t; // 使用T的输出运算符打印t的一个表示形式
		return ret.str();// 返回ret 绑定的string的一个副本
}

template <typename T> 
string debug_rep(T* p)
{
	cout << "使用了T*p版本" << endl;
	ostringstream ret;  // 打印指针本身的值
	ret << "pointer: " << p;
		if (p)
			ret << "" << debug_rep(*p);// 打印p指向的值
		else
			ret << " null pointer"; // 或指出ρ为空
			return ret.str();// 返回ret 绑定的string的一个副本
}
	int main()
{
		string s("hi");
		cout << debug_rep(s)<<endl;
}

对于这个调用,只有第一个版本的debug_rep是可行的。

第二个debug_rep版本要求一个指针参数,但在此调用中我们传递的是一个非指针对象。

因此编译器无法从一个非指针实参实例化一个期望指针类型参数的函数模板,因此实参推断失败。

由于只有一个可行函数,所以此函数被调用。

如果我们用一个指针调用 debug_rep:

cout << debug_rep(&s)<<endl;

两个函数都生成可行的实例:

  1. debug _rep (const string*&),由第一个版本的debug_rep实例化而来,被绑定到string*。
  2. debug_rep(string*),由第二个版本的debug_rep实例化而来,T被绑定到string。

第二个版本的debug rep的实例是此调用的精确匹配。

第一个版本的实例需要进行普通指针到 const指针的转换。

正常函数匹配规则告诉我们应该选择第二个模板,实际上编译器确实选择了这个版本。

#include<iostream>
#include<sstream>
using namespace std;
//打印任何我们不能处理的类型
template <typename T> 
string debug_rep(const T& t)
{
	cout << "使用了const T&t版本" << endl;
	ostringstream ret;
	ret << t; // 使用T的输出运算符打印t的一个表示形式
		return ret.str();// 返回ret 绑定的string的一个副本
}


template <typename T> 
string debug_rep(T* p)
{
	cout << "使用了T*p版本" << endl;
	ostringstream ret;  // 打印指针本身的值
	ret << "pointer: " << p;
		if (p)
			ret << "" << debug_rep(*p);// 打印p指向的值
		else
			ret << " null pointer"; // 或指出ρ为空
			return ret.str();// 返回ret 绑定的string的一个副本
}
int main()
{
	string s("hi");
	string result = debug_rep(&s); // 将函数返回值存储在result变量中  
	cout << result << endl; // 打印result变量,即debug_rep函数的返回值  
}

我们打开调试面板,在执行函数调用语句时,直接跳进了第二个模板函数

有人就好奇了为什么会出现第二行的提示

这里的关键在于模板函数的实例化和递归调用。当您调用 debug_rep(&s) 时,由于传递了一个指针,所以编译器会选择第二个模板函数 debug_rep(T* p) 进行实例化。在这个函数内部,当指针 p 不为空时,会递归调用 debug_rep(*p)

递归调用 debug_rep(*p) 时,传递的是指针 p 所指向的值,即字符串 s 的一个引用。因此,编译器会选择第一个模板函数 debug_rep(const T& t) 进行实例化,其中 T 被推导为 std::string

在第一个模板函数内部,cout 语句会首先执行,打印出 "使用了const T&t版本"。接着,函数会使用输出运算符 << 将 t(即字符串 s)插入到一个 ostringstream 对象中,并最终返回这个对象转换成的字符串。

因此,当您运行程序时,会看到 "使用了const T&t版本" 被打印出来,这是因为在递归调用中第一个模板函数被实例化并执行了。

多个可行模板

作为另外一个例子,考虑下面的调用:

const string *sp = &s;
cout << debug_rep(sp) << endl;

此例中的两个模板都是可行的,而且两个都是精确匹配:

  • debug_rep(const string*&),由第一个版本的debug_rep实例化而来,T被绑定到string*。
  • debug_rep(const string*),由第二个版本的debug rep 实例化而来,T被绑定到 const string。

在此情况下,正常函数匹配规则无法区分这两个函数。我们可能觉得这个调用将是有歧义的。

但是,根据重载函数模板的特殊规则,此调用被解析为debug rep(T*),即,更特例化的版本。

设计这条规则的原因是,没有它,将无法对一个const的指针调用指针版本的debug_rep。

问题在于模板 debug rep(const T&)本质上可以用于任何类型,包括指针类型。此模板比debug_rep(T*)更通用,后者只能用于指针类型。没有这条规则,传递const的指针的调用永远是有歧义的。

当有多个重载模板对一个调用提供同样好的匹配时,应选择最特例化的版本。

#include<iostream>
#include<sstream>
using namespace std;
//打印任何我们不能处理的类型
template <typename T> 
string debug_rep(const T& t)
{
	cout << "使用了const T&t版本" << endl;
	ostringstream ret;
	ret << t; // 使用T的输出运算符打印t的一个表示形式
		return ret.str();// 返回ret 绑定的string的一个副本
}


template <typename T> 
string debug_rep(T* p)
{
	cout << "使用了T*p版本" << endl;
	ostringstream ret;  // 打印指针本身的值
	ret << "pointer: " << p;
		if (p)
			ret << "" << debug_rep(*p);// 打印p指向的值
		else
			ret << " null pointer"; // 或指出ρ为空
			return ret.str();// 返回ret 绑定的string的一个副本
}
int main()
{
	string s("hi");
	const string* sp = &s;
	cout << debug_rep(sp) << endl;
}

事实证明,确实是调用了T*版本

非模板和模板重载

作为下一个例子,我们将定义一个普通非模板版本的debug_rep来打印双引号包围的string:

string debug_rep(const string& s)
{
	return '"' + s + '"';
}


现在,当我们对一个string 调用debug_rep时:

string s("hi");
	cout << debug_rep(s) << endl;


有两个同样好的可行函数:

  • debug_rep<string>(const string&),第一个模板,T被绑定到string*。
  • debug_rep(const string&),普通非模板函数。

在本例中,两个函数具有相同的参数列表,因此显然两者提供同样好的匹配。但是,编译委会选择非模板版本。

当存在多个同样好的函数模板时,编译器选择最特例化的版本,出于相同的原因, 一个非模板函数比一个函数模板更好。

#include<iostream>
#include<sstream>
using namespace std;
//打印任何我们不能处理的类型
template <typename T> 
string debug_rep(const T& t)
{
	cout << "使用了const T&t版本" << endl;
	ostringstream ret;
	ret << t; // 使用T的输出运算符打印t的一个表示形式
		return ret.str();// 返回ret 绑定的string的一个副本
}


template <typename T> 
string debug_rep(T* p)
{
	cout << "使用了T*p版本" << endl;
	ostringstream ret;  // 打印指针本身的值
	ret << "pointer: " << p;
		if (p)
			ret << "" << debug_rep(*p);// 打印p指向的值
		else
			ret << " null pointer"; // 或指出ρ为空
			return ret.str();// 返回ret 绑定的string的一个副本
}

//打印双引号包围的string
string debug_rep(const string& s)
{
	return '"' + s + '"';
}

int main()
{
	string s("hi");
		cout << debug_rep(s) << endl;
}

对于一个调用,如果一个非函数模板与一个函数模板提供同样好的匹配,则选择非模板版本。

重载模板和类型转换

还有一种情况我们到目前为止尚未讨论:C风格字符串指针和字符串字面常量。

现在有了一个接受string的debug_rep版本,我们可能期望一个传递字符串的调用会匹配这个版本。但是,考虑这个调用:
 

cout << debug_rep("hi world!") << endl; // 调用debug_rep(T*)

本例中所有三个debug rep版本都是可行的:

  1. debug rep(const T&),T被绑定到char[10]。
  2. debug rep(T*),T被绑定到const char。
  3. debug rep(const string&),要求从const char*到string的类型转换。

对给定实参来说,两个模板都提供精确匹配——第二个模板需要进行一次(许可的)数组到指针的转换,而对于函数匹配来说,这种转换被认为是精确匹配。

非模板版本是可行的,但需要进行一次用户定义的类型转换,因此它没有精确匹配那么好,所以两个模板成为可能调用的函数。

与之前一样,T*版本更加特例化,编译器会选择它。

#include<iostream>
#include<sstream>
using namespace std;
//打印任何我们不能处理的类型
template <typename T> 
string debug_rep(const T& t)
{
	cout << "使用了const T&t版本" << endl;
	ostringstream ret;
	ret << t; // 使用T的输出运算符打印t的一个表示形式
		return ret.str();// 返回ret 绑定的string的一个副本
}


template <typename T> 
string debug_rep(T* p)
{
	cout << "使用了T*p版本" << endl;
	ostringstream ret;  // 打印指针本身的值
	ret << "pointer: " << p;
		if (p)
			ret << "" << debug_rep(*p);// 打印p指向的值
		else
			ret << " null pointer"; // 或指出ρ为空
			return ret.str();// 返回ret 绑定的string的一个副本
}

//打印双引号包围的string
string debug_rep(const string& s)
{
	return '"' + s + '"';
}

int main()
{
	cout << debug_rep("hi world!") << endl; // 调用debug_rep(T*)
}

如果我们希望将字符指针按string处理,可以定义另外两个非模板重载版本:

//将字符指针转换为string,并调用string版本的debug_reg
string debug_rep(char* p)
{
	return debug_rep(string(p));
}
string debug_rep(const char* p)
{
		return debug_rep(string(p));
}

缺少声明可能导致程序行为异常

值得注意的是,为了使 char*版本的 debug_rep 正确工作,在定义此版本时,debug_rep (const string)的声明必须在作用域中。否则,就可能调用错误的debug_rep版本:

template <typename T> string debug_rep(const T& t);
template<typename T> string debug_rep(T* p);

// 为了使debug_rep(char*)的定义正确工作,下面的声明必须在作用域中
string debug_rep(const string&);

string debug_rep(char* p)
{

// 如果接受一个const string&的版本的声明不在作用域中,

// 返回语句将调用 debug_rep(const T&)的T实例化为string的版本

return debug_rep(string(p));
}


通常,如果使用了一个忘记声明的函数,代码将编译失败。

但对于重载函数模板的函数而言,则不是这样。

如果编译器可以从模板实例化出与调用匹配的版本,则缺少的声明就不重要了。

在本例中,如果忘记了声明接受string参数的debug_rep版本,编译器会默默地实例化接受const T&的模板版本。

#include<iostream>
#include<sstream>
using namespace std;
//打印任何我们不能处理的类型
template <typename T> 
string debug_rep(const T& t)
{
	cout << "使用了const T&t版本" << endl;
	ostringstream ret;
	ret << t; // 使用T的输出运算符打印t的一个表示形式
		return ret.str();// 返回ret 绑定的string的一个副本
}


template <typename T> 
string debug_rep(T* p)
{
	cout << "使用了T*p版本" << endl;
	ostringstream ret;  // 打印指针本身的值
	ret << "pointer: " << p;
		if (p)
			ret << "" << debug_rep(*p);// 打印p指向的值
		else
			ret << " null pointer"; // 或指出ρ为空
			return ret.str();// 返回ret 绑定的string的一个副本
}



string debug_rep(char* p)
{
// 如果接受一个const string&的版本的声明不在作用域中,
// 返回语句将调用 debug_rep(const T&)的T实例化为string的版本
return debug_rep(string(p));
}


int main()
{
	cout << debug_rep("hi world!") << endl; // 调用debug_rep(T*)
}

 

在定义任何函数之前,记得声明所有重载的函数版本。这样就不必担心编译器T由于未遇到你希望调用的函数而实例化一个并非你所需的版本。
 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1566407.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

数据恢复工具可以恢复所有丢失的文件吗

随着数字时代的快速发展&#xff0c;数据已经成为我们生活与工作中不可或缺的一部分。然而&#xff0c;数据丢失的风险也随之增大。无论是由于误删除、误格式化、病毒感染还是其他意外情况&#xff0c;数据丢失都可能带来不小的损失。在这种情况下&#xff0c;数据恢复工具应运…

揭开AI编程语言Mojo比Pyhon快6.8万倍的5个秘密!

最近&#xff08;2024年3月29日&#xff09;&#xff0c;号称比Python快6.8万倍的Mojo编程语言开源啦&#xff01;6.8万倍&#xff1f;你敢相信这个数字是真的吗&#xff1f;不过&#xff0c;就连Mojo官网都把这个结果贴了出来&#xff08;见下图&#xff09;&#xff0c;这就很…

Java快速入门系列-1(Java概述)

第一章&#xff1a;Java概述 1.1 Java的发展历程1.2 Java的特点与优势1.2.1 特点1.2.2 优势 1.3 Java生态系统介绍1.4 Java在当前技术领域的应用案例 1.1 Java的发展历程 Java语言由Sun Microsystems公司于1995年推出&#xff0c;由James Gosling领导的Green Team小组研发而成…

孙崧-回归祖国的数学天才谈国外学习研究感受

孙崧&#xff0c;这位37岁的美国加州大学伯克利分校数学系教授&#xff0c;今年正式回归祖国&#xff0c;担任浙江大学数学高等研究院杜建英讲席教授、博士生导师。在此&#xff0c;知识人网小编就经历过国外就读、从事博士后研究及任教的这位数学天才是怎么说的&#xff0c;或…

文心一言指令词宝典之旅行篇

作者&#xff1a;哈哥撩编程&#xff08;视频号、抖音、公众号同名&#xff09; 新星计划全栈领域优秀创作者博客专家全国博客之星第四名超级个体COC上海社区主理人特约讲师谷歌亚马逊演讲嘉宾科技博主极星会首批签约作者 &#x1f3c6; 推荐专栏&#xff1a; &#x1f3c5;…

02-JDK新特性-Stream流

Stream流 什么是Stream流 Stream流是Java 8中的一个新特性&#xff0c;它提供了一种处理集合和数组的方式。Stream流可以让我们以一种更加简洁、高效、可读性更强的方式来处理数据。 Stream流可以用于过滤、映射、排序、聚合等操作&#xff0c;它可以让我们避免使用循环和条件…

商务电子邮件: 在WorkPlace中高效且安全

高效和安全的沟通是任何组织成功的核心。在我们关于电子邮件类型的系列文章的第二期中&#xff0c;我们将重点关注商业电子邮件在促进无缝交互中的关键作用。当你身处重要的工作场环境时&#xff0c;本系列的每篇文章都提供了电子邮件的不同维度的视角。 “2024年&#xff0c;全…

互联网轻量级框架整合之Spring框架II

持久层框架 Hibernate 假设有个数据表&#xff0c;它有3个字段分别是id、rolename、note, 首先用IDEA构建一个maven项目Archetype选择org.apache.maven.archetypes:maven-archetype-quickstart即可&#xff0c;配置如下pom <project xmlns"http://maven.apache.org/…

解决Centos7无法连接网络和访问网页连接不上问题

一、网络无法连接问题 网络无法连接的问题我查到了一个很良心的操作&#xff0c;不用重装&#xff0c;因为可能是你虚拟机设置上的问题。我先写我的解决方案&#xff0c;再附上其他几种解决方案。 问题一&#xff1a; 虚拟机的问题****加粗样式 解决&#xff1a; &#xff08;…

自动驾驶传感器:带你搞懂卫星导航GPS-RTK原理

自动驾驶传感器&#xff1a;带你搞懂卫星导航GPS-RTK原理 附赠自动驾驶学习资料和量产经验&#xff1a;链接 0. 前言 自动驾驶的感知层里面&#xff0c;前面Lidar&#xff0c;Radar&#xff0c;Camera的介绍之前已写完。还差GNSS-RTK和IMU模块就补齐了主要的自动驾驶感知层的…

Kubernetes Pod的网络暴露

这里先介绍下Pod的网络暴露&#xff0c;后面复习到service暴露再作更新 一、hostNetwork使用宿主机的网络 1、编写pod-hostnetwork.yaml 配置文件中pod的spec.hostNetwork: true 的配置可实现 apiVersion: v1 kind: Pod metadata:name: pod-hostnetwork spec:hostNetwork: …

一文了解 2024 美国流媒体行业动态

Tubi 每年都会发布流媒体市场研究报告&#xff0c;这既是对流媒体市场的深入参与和贡献&#xff0c;也能帮助广告商深入理解流媒体用户群体和 Tubi 的独特优势。 近日&#xff0c;Tubi 发布了 2024 年美国流媒体市场调研报告&#xff0c;本文将概要介绍其中的关键内容&#xf…

C++——list类及其模拟实现

前言&#xff1a;这篇文章我们继续进行C容器类的分享——list&#xff0c;也就是数据结构中的链表&#xff0c;而且是带头双向循环链表。 一.基本框架 namespace Mylist {template<class T>//定义节点struct ListNode{ListNode<T>* _next;ListNode<T>* _pre…

蓝牙Simple Peripheral工程学习

前言 TI BLE SDK提供了Simple Peripheral工程,初学者可以通过这个工程来学习基本的蓝牙知识,通过实操掌握蓝牙基本的理论与通信方式。 在介绍这个工程前,先为大家介绍蓝牙Peripheral与Central的区别。如下图GAP主要负责Ble设备的连接,GAP状态机描述了设备空闲、设备发现与…

MySQL的基本操作(超详细)

&#x1f468;‍&#x1f4bb;作者简介&#xff1a;&#x1f468;&#x1f3fb;‍&#x1f393;告别&#xff0c;今天 &#x1f4d4;高质量专栏 &#xff1a;☕java趣味之旅 &#x1f4d4;&#xff08;零基础&#xff09;专栏&#xff1a;MSQL数据库 欢迎&#x1f64f;点赞&…

计算机网络_工具

从你的电脑到指定ip网站&#xff0c;用时3ms ttl TTL Time To Live 数据包存活时间 指一个数据包在经过一个路由器时&#xff0c;可传递的最长距离&#xff08;跃点数&#xff09;。每当数据包经过一个路由器时&#xff0c;其存活次数就会被减一 256 - 249 7&…

大日志精选案例五:某教育局网络安全与信息化工作稳步推进

“教育网络安全&#xff0c;是保障学校正常运行和教育质量的重要基石。日志&#xff0c;作为记录系统运行和网络访问关键事件的重要载体&#xff0c;对于发现安全隐患和威胁具有不可替代的作用。我们一直在探寻更为高效、精准的日志管理策略。聚铭的大日志方案&#xff0c;成功…

HarmonyOS 应用开发之非线性容器

非线性容器实现能快速查找的数据结构&#xff0c;其底层通过hash或者红黑树实现&#xff0c;包括HashMap、HashSet、TreeMap、TreeSet、LightWeightMap、LightWeightSet、PlainArray七种。非线性容器中的key及value的类型均满足ECMA标准。 HashMap HashMap 可用来存储具有关联…

C语言 | Leetcode C语言题解之第5题最长回文子串

题目&#xff1a; 题解&#xff1a; char* longestPalindrome(char* s) {int lenstrlen(s),max0;int p0;for(int i0;i<len;i)//这种是判断奇数回文{int lefti-1,righti1;//left左边&#xff0c;right右边while(left>0&&right<len&&s[left]s[right]){/…