函数模版、重载和特化的匹配规则

函数匹配规则:

1.对于一个调用,其候选函数包括所有模版实参推断成功的函数模版实例(顶层const可忽略;对于非引用的形参,数组或函数指针转化到到指针)

2.可行函数(模版和非模版),按类型转换排序

3.如果恰有一个函数比其它都更匹配,则选择此函数,否则

a.如果只有一个非模版函数,选择他,

b.没有非模版函数,选择更特例化的模版

c.否则,有歧义,编译错误

注意:
函数特例化的本质是实例化一个模板,而非重载它,所以特例化的版本不影响函数匹配。也就是说函数匹配时只比较模版函数,模版函数重载,普通函数,不考虑特例化。只有选择了匹配了该函数模板后才会考虑该模板下的特化版本。
#include<iostream>

using namespace std;
template<class t>
inline bool LESS(const t& t1, const t& t2)
{
	cout<<"general   ";
	return t1<t2?1:0;
}
template<class t>
inline bool LESS( t* const t1,  t* const t2)
{
	cout<<"overload1  ";
	return *t1<*t2?1:0;
}
template<class t>
inline bool LESS(const t* const t1, const t* const t2)
{
	cout<<"overload2  ";
	return *t1<*t2?1:0;
}
int main()
{
	int int1=10;
	int int2=20;
	int* pint1 = &int1;
	int* pint2 = &int2;
	const int* cpint1 = &int1;
	const int* cpint2 = &int2;
	cout<< LESS(int1,int2) <<endl;//general 
	cout<< LESS(pint1,pint2) <<endl;//overload1
	cout<< LESS(cpint1,cpint2) <<endl;//overload2
}
对于第二个LESS,三个版本都是可行的。对于第一个版本,t绑定到int*,生成的可行的实例是LESS(const int* & t1, const int* & t2),需要一次普通指针到const指针的转换;对于第二个版本是精确匹配;对于第三个版本,t绑定到int,生成的可行的实例是LESS(const int*  t1, const int*  t2),需要一次普通指针到const指针的转换。规则3,所以选择第二个版本。
对于第三个LESS,三个版本都是可行的。对于第一个版本,t绑定到int*,生成的可行的实例是LESS(const int* & t1, const int* & t2);t绑定到const int*,生成的可行的实例是LESS(const int*  t1, const int*  t2);对于第三个版本,t绑定到int,生成的可行的实例是LESS(const int*  t1, const int*  t2)。规则3.b,三个版本中,他们的通用程度依次降低,所以选择第三个版本。

#include<iostream>
#include<cstring>
using namespace std;

//函数模版只能全特化,不能偏特化,但是可以重载呀
template<class t>
inline bool LESS(const t& t1, const t& t2)//本质上可用于任何类型,包括指针类型。 
{
	cout<<"general   ";
	return t1<t2?1:0;
}
template<class t>//指针类型的重载版 ,只能用于指针类型,所以比上一个更特例化 。 
inline bool LESS(t* const t1, t* const t2)
{
	cout<<"overload1  ";
	return *t1<*t2?1:0;
}
template<class t>//const指针类型的重载版 ,只能用于const指针类型,所以比上一个更特例化 。 
inline bool LESS(const t* const t1, const t* const t2)
{
	cout<<"overload2  ";
	return *t1<*t2?1:0;
}

bool LESS(const char* const t1, const char* const t2)//普通函数版本,优先级更高 
{
	cout<<"function  ";
	return strcmp(t1,t2);
}

template<>
inline bool LESS<char>(const char &t1, const char &t2)//特化 template<class t> t LESS(const t& t1, const t& t2)
{
	cout<<"special_one   ";
	return t1<t2?1:0;
}
template<>
inline bool LESS<const int*>(const int* const &t1, const int* const &t2)//特化 template<class t> t LESS(const t& t1, const t& t2)
{
	cout<<"special_two   ";
	return *t1<*t2?1:0;
}

int main()
{
	int int1=10;
	int int2=20;
	int* pint1 = &int1;
	int* pint2 = &int2;
	char c1 = 'a';
	char c2 = 'z';
	const char* cc1 = "abc";
	const char* cc2 = "abc";

	cout<< LESS(pint1,pint2) <<endl;//overload1
	cout<< LESS(c1,c2) <<endl;//special_one 
	cout<< LESS(cc1,cc2) <<endl;//function
	cout<< LESS("hi","zzzz") <<endl;//function
}
第一个LESS,可行的函数有general,overload1,overload2;其中overload1版本精确匹配,其它两个需要const转换;虽然general也有一个完全匹配的特化版本special_two,但是“只有选择了匹配了该函数模板后才会考虑该模板下的特化版本”,所以special_two根本就没有参与到匹配中。
第二个LESS,可行的只有general版本,所以选择它,同时发现有char类型的全特化版本,所以选择special_one。
第三个LESS,可行的有general,overload2和普通函数。对于general,t绑定到char*,生成的可行的实例是LESS(const char* & t1, const int* & t2),精确匹配;对于overload2,t绑定到chat,生成的可行的实例是LESS(const char*  t1, const char*  t2),精确匹配;对于普通函数,也是精确匹配。规则3.a,所以选择普通函数版本。

所以总结一下,在候选的函数中,优先在精确匹配中选择,优先选择普通函数,特例性更强的模版函数次之,然后是模版函数的特化版本,最后才是泛化版本。

展开阅读全文

没有更多推荐了,返回首页