C++ Template重载函数模板（2.4节）

    和普通函数一样，函灵敏模板也可以被重载。就是说，相同的函数名称可以具有不同的函数定义：于是，当使用函数名称进行函函数调用的时候，C++编译器必须决定究竟要调用哪个候选 函数。

//重载函数模板

#include <iostream>
#include <string>

//求两个int值的最大值
inline int const& max(int const &a, int const& b)
{
	std::cout << "a====" << a << "   b====" << b << std::endl;
	return a < b ? b : a;
}

//求两个任意类型值中的最大者
template <typename T>
inline T const& max(T const& a, T const& b)
{
	return a < b ? b : a;
}


//求3个任意类型值中的最大者
template<typename T>
inline T const& max(T const& a, T const& b, T const& c)
{
	return ::max(::max(a, b), c);
}



int main()
{
	std::cout << "::max(7, 42, 68)=======" << ::max(7, 42, 68) << std::endl;  //调用具有3个参数的模板
	std::cout << "::max(7.0, 42.0)=======" << ::max(7.0, 42.0) << std::endl; //调用max<double> (通过实参演绎)函数模板
	std::cout << "::max('a', 'b')========" << ::max('a', 'b') << std::endl; //调用max<char> (通过实参演绎)函数模板
	std::cout << "::max(7, 42)===========" << ::max(7, 42) << std::endl;  //调用int重载的非模板函数
	std::cout << "::max<>(7, 42)===========" << ::max<>(7, 42) << std::endl;  //调用max<int>(通过实参演绎)
	std::cout << "::max<double>(7, 42)===========" << ::max<double>(7, 42) << std::endl;  //调用max<double>(没有实参演绎，指定T的类型为double)
	std::cout << "::max('a', 42.7)===========" << ::max('a', 42.7) << std::endl;  //调用int重载的非模板函数
}

如例子所示，一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

对于非模板函数和同名的函数模板，如果其他条件都 是相同的话，那么在调用的时候，重载解析过程通常会调用非模板函数，

而不会从该模板产生出一个函例。max(7, 42) //匹配非模板函数

    如果模板可以产生一个具有更好匹配的函数，那么将选择模板。这可以通过max()的第2次和第3次调用来说明：

max(7.0, 42.0); //调用max<double>(通过实参演绎)

max('a', 'b');  //调用max<char>（通过实参演绎）

还可以显示地指定一个空的模板实参列表，这个语法好像是告诉编译器：只有模板才能来匹配这个调用，而且所有的模板参数都应该根据调用实参演绎出来：

max<>(7, 42)  //调用max<int> (通过实参演绎)

因为模板是不允许自动类型转化的：但普通函数可以进行自动类型转换，所以最后一个调用将使用非模板函数（'a'和42.7都被转化为int）:

max('a', 42.7)//对于不同类型的参数，只允许使用非模板函数

========================================================================

下面这个更有用的例子将会为指针和普通的C字符串重载这个求最大值的模板

//重载函数模板

#include <iostream>
#include <string>
#include <cstring>


//求两个任意类型值中的最大者
template <typename T>
inline T const& max(T const& a, T const& b) 
{
	return a < b ? b : a; 
}

//求两个指针所指向值的最大者
template<typename T>
inline T* const& max(T* const& a, T* const &b)
{
	return *a < *b ? b : a;
}

//求两个C字符串的最大者
inline char const* const& max(char const* const& a, char const* const& b)
{
	return std::strcmp(a, b) < 0 ? b : a;
}

int main()
{
	int a = 7;
	int b = 42;
	std::cout << "max(a, b)========" << ::max(a, b) << std::endl;//max()求两个int值的最大值

	std::string s = "hey";
	std::string t = "you";
	std::cout << "max(s, t)========" << ::max(s, t) << std::endl;//max()求两个std::string值的最大值

	int *p1 = &b;
	int *p2 = &a;
	std::cout << "max(p1, p2)========" << ::max(p1, p2) << std::endl;//max()求两个指针指向值的最大者

	char const *s1 = "David";
	char const *s2 = "Nico";
	std::cout << "max(s1, s2)========" << ::max(s1, s2) << std::endl;//max()求两个c字符串的最大值
}

    在所有重载的实现里面，都是通过引用来传递每个实参的。一般而言，在重载函数模板的时候，最好只是改变那些需要改变的内容；就是说，你应该把你的改变限制在下面两种情况：改变参数的数目或者显示地指定模板参数。否则就可能会出现非预期的结果。例如，对于在来使用传引用的max()模板，你用C-string类型进行重载；但对于现在（即重载版本）基于C-strings的max()函数，你是通过传值 来传递参数；那么你就不能使用3个参数的max()版本，来对3个C-string求最大值 ：

//重载函数模板 字符串比较

#include <iostream>
#include <string>
#include <cstring>


//求两个任意类型值中的最大者(通过传引用进行调用)
template <typename T>
inline T const& max(T const& a, T const& b) 
{
	return a < b ? b : a; 
}


//求两个C字符串的最大者（通过传值 进地调用）
inline char const* const max(char const* a, char const* b)
{
	return std::strcmp(a, b) < 0 ? b : a;
}

//求3个任意类型值 的最大者（通过传引用进行调用）
template<typename T>
inline T const& max(T const& a, T const& b, T const& c)
{
	return max(max(a, b), c);//注意：如果max(a, b)使用传值调用，那么将会发生错误
}

int main()
{
	std::cout << "max(7, 34， 23)========" << ::max(7, 34, 23) << std::endl;//max()求3个int值的最大值
	char const *s1 = "David";
	char const *s2 = "Nico";
	char const *s3 = "Anica";
	//错误:调用max(char const* a, char const* b)返回的是一个局部变量或临时变量的地址
	//std::cout << "max(s1, s2， s3)========" << ::max(s1, s2, s3) << std::endl;
}

=============================================================

函数的所有重载版本的声明都应该位于该函数被调用的位置之前。如果函数的定义在使用调用之后，则相同情况下不会调用之后定义的。例如：

//重载函数模板 字符串比较

#include <iostream>
#include <string>
#include <cstring>


//求两个任意类型值中的最大者(通过传引用进行调用)
template <typename T>
inline T const& max(T const& a, T const& b) 
{
	std::cout << "max=templates====a===" << a << "  ==== b===" << b << std::endl;
	return a < b ? b : a; 
}


//求3个任意类型值 的最大者（通过传引用进行调用）
template<typename T>
inline T const& max(T const& a, T const& b, T const& c)
{
	return max(max(a, b), c);//使用了模板的版本，即使有下面声明的int版本，也不会调用
}

//求两个int值 的最大者
inline int const& max(int const& a, int const& b)
{
	std::cout << "max=====a===" << a << "  ==== b===" << b << std::endl;
	return a < b ? b : a;
}

int main()
{
	std::cout << "max(7, 34， 23)========" << ::max(7, 34, 23) << std::endl;//max()求3个int值的最大值
	return 0;
}

把max函数移到模板函数之前运行