C++重载和模板

最新推荐文章于 2024-08-07 16:45:42 发布
最新推荐文章于 2024-08-07 16:45:42 发布
阅读量1.4k 收藏 23
点赞数 41
分类专栏： C++（不含类部分和STL部分） 文章标签： 开发语言 c++ c语言 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80224556/article/details/137356603
版权

重载与模板

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

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

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

  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由于未遇到你希望调用的函数而实例化一个并非你所需的版本。
 

掘根
关注
专栏目录
函数模板与重载
学习
03-02 520
函数模板与重载
模板类的重载
weixin_45419976的博客
03-11 451
放代码： #include<iostream> #include<cstdio> #define USE_OS template<class T>class ArrayList; template<class T>std::ostream &operator<<(std::ostream &os,const ArrayList<T> &obj); class error : public std::e...
学懂C++ （十）：详解C++重载与模板的关系和匹配规则
最新发布
martian665的专栏
08-07 878
详解C++重载与模板的关系和匹配规则
模板函数的重载
tyrmer的专栏
11-05 697
由于template不支持函数的偏特化，所以我们需要利用重载来处理。 假如有一个函数create定义如下 template T* Create(const U & arg) { return new T(arg); } 我们需要对这个函数偏特化处理，如果模板支持函数的偏特化，则应该是这样定义 //非法的定义 template widget* Create(const U
C++程序函数的重载和函数模板
觉醒法师的专栏
03-18 861
在C++中，函数也可以重载。C++允许在同一作用域中用同一函数名定义多个函数，这些函数的参数个数和参数类型不相同，这些同名的函数用来实现不同的功能，这就是函数的重载。函数的重载的函数体是完全相同的，只是形参和类型不同，也要分别定义。为了解决这个问题，C++提供了函数模板（function template）。函数模板，实际上是建立一个通用函数类型和形参类型不具体指定，用一个虚拟的类型来代表，这个通用函数就称为函数模板。
C++类模板的重载
weixin_41111116的博客
11-12 2148
C++类模板的重载
C++中函数重载和函数模板的理解
01-20
C++真心难，第一遍是我一年前看的。现在再看感觉好像全新的一样。。。 　好了，简单介绍下函数重载，学过编程的都对这个重载很熟悉了。函数重载的判断标识是它的函数参数列表，而不是返回值来判断的。所以像 ...
c++ 运算符重载和方法重载
01-08
strcmp（s1，s2）比较s1和s2字符串内容是否相同 strcat（s1，s2）拼接字符串，把s2拼接在s1的末尾 strchr（s1，ch）找到s1这个字符串里面第一次出现ch这个字符的位置 strstr（s1，s2）找到字符串s1里面第一次出现s2...
c++运算符重载和模板
01-05
模板有两种形式：函数模板和类模板。函数模板可以创建一个通用的函数，适用于各种数据类型，而类模板则用于创建可以处理多种类型的类。 1. **函数模板**：函数模板定义了一个通用的函数，编译器会根据传入的参数...
C++接口、重载和模板
05-14
通过学习C++的类、接口、重载和模板，开发者能够更好地理解和利用面向对象编程的特性，编写出高效、灵活且易于维护的代码。这些知识点对于C++的中高级开发人员来说至关重要，能够帮助他们在复杂项目中游刃有余。
模板类重载，模板类特化
Hello world！
05-11 842
函数重载大家都很熟悉了。就是函数名相同的几个东西。但是在读源码的时候发现了一次模板类同名的地方。但是出现了三个模板类。后来发现，原来这是模板类特化，就是对于那种类型的模板，不用通用的模板定义，而是特殊化一个实现。 template class A{}; template{};这儿A类对于bool有单独的实现。这个叫specialization templat 英文定义。 http://ww
C++学习总结（二十四）——类模板元编程，类模板重载
IM_GD
04-29 462
一.类模板元编程#include&lt;iostream&gt; template&lt;int N&gt; struct data { enum { res = data&lt;N - 1&gt;::res + data&lt;N - 2&gt;::res}; }; template&lt;&gt; struct data&lt;1&gt; { enum{res=1}; }; templat...
函数模板的重载
fireeeea的博客
04-24 214
#include&lt;iostream&gt;using namespace std;template &lt;class T1,class T2&gt;void Print(T1 arg1,T2 arg2){    cout&lt;&lt;arg1&lt;&lt;" "&lt;&lt;arg2&lt;&lt;endl;    cout&lt;&lt;"模板一被调用
【数据结构】（一）模板 重载
张林克的博客
10-21 270
基本概念
函数模板，重载函数模板，模板的显式具体化，实例化
m0_63783532的博客
10-16 2170
定义好函数模板后，当程序需要该函数模板定义的具体类型的函数时，编译器会根据该函数模板生成具体类型的函数定义，这种实例化方式被称为隐式实例化。例如：函数调用Swap(i, j)导致编译器生成Swap()的一个实例，该实例使用int类型。模板并非函数定义，但使用int的模板实例是函数定义。同时编译器之所以知道需要进行定义，是由于程序调用Swap()函数时提供了int参数。直接命令编译器创建特定的实例，如Swap ()。template[函数返回类型][函数模板名]（函数参数列表）
C++ | 函数模板的重载（模板重载）
ThinPikachu的博客
07-18 5315
所谓的函数模板的重载是指，普通函数的版本，函数模板的版本和函数模板特例化的版本可以共存，例如： //普通函数版本 bool Compare(char* a, char* b) { cout << "普通函数版本" << endl; return strcmp(a, b) > 0; } //函数模板版本 template<typename T> bool Compare(T a, T b) { cout << "函数模板版本" <<
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值