函数重载

函数重载允许我们创建名称相同的函数，但是为了编译器能够正确的编译这个程序，这些函数采用不同的参数列表来区分，比如：

int ave(int a,int b){
    return (a+b)/2;
}

int ave(int a,int b,int c){
    return (a+b+c)/3;
}

float ave(float a,float b,float c){
    return (a+b+c)/3；
}

int main(){
    cout<<ave(2,3);
    cout<<ave(2,3,4);
    cout<<ave(2.0f,3.0f); //这个就会调用 第一个int ave(int a,int b)
}

若是增加了一个代码

float ave(int a,int b){return (a+b)/2;}

再次调用这个这个函数会报错

cout<<ave(2.0f,3.0f);

因为编译器无法单纯的通过返回值来确定你要返回的函数

所以以下这样的函数就是不能重载的：

int ave(int a,int b); 和 float ave(int a,int b);

int ave(int*,int); 和 int ave(int[],int); //本质上同为指针

还有特殊案例：

int ave(int a,int b); 和 int ave(int& a,int& b);
//传入 1,2 编译的时候能通过，但是遇到a = 1, b = 2; 传入 a 、 b时会产生歧义，所以编译不能通过;


//----------------------------------------------------//


int ave(int a,int b); 和 int ave(const int  a,const int b);// 也不行

//----------------------------------------------------//

//但是 当存在 
const int a = 10; const int b = 10;
int ave(int& a,int& b); 和 int ave(const int& a,const int& b);// 可行


//----------------------------------------------------//


int ave(int& a, int& b) {
    cout << "两个 int 参数";
    return (a + b) / 2;
}

float ave(float a, float b) {
    cout << "两个 float 参数";
    return (a + b) / 2;
}

int main() {
    float a = 10, b = 10;
    cout << ave((int)a,(int)b); //调用的还是float ave(float a, float b)；
    //零时变量没有引用（即指针地址）}
    return 0;
}

函数重载的时候不能设置缺省参数

函数模板

基本语法

template <typename type1>
type1 ave(type1 a,type2 b){
    type1 c = a + b;
    return c/2;
}

//多个类型
template <typename T1,typename T2,typename T3>
T3 ave(T2 a,T1 b){
//............
}

使用案例

ave<int>(int a,int b);
ave<float><float a,float b>;

模板例外和重载(优先级情况)

#include <iostream>
using namespace std;

template<typename type1>
type1 bigger(type1 a, type1 b) {
	cout << "模板1" << endl;
	return a > b ? a : b;
}

//模板的重载
template<typename type1>
type1 bigger(type1 a, type1 b,type1 c) {
	cout << "模板重载" << endl;
	return a+b+c;
}

template<>
int bigger(int a, int b) {
	cout << "模板例外"<< endl;
	return *a > *b ? a : b;
}

int bigger(int a, int b) {
	cout << "重载"<< endl;
	return a > b ? a : b;
}

void main() {
	int a{ 10 };
	int b{ 12 };
	cout << bigger(&a,&b);
}

优先级重载>例外>模板

函数模板参数

模板默认参数

template <typename TR = int,typename T1,typename T2>
TR ave(T1 a,T2 b){return (a+b)/2;}//返回指定的类型

main(){
    ave()<<(100,200);//当没指定 数据类型时 就默认
    ave()<float>(100,200);
}

非类型的模板参数

//模板函数可以有非类型的模板参数
template <int max,int min,typename T1>
bool AddHp(T1& Hp,type damage){
    hp-=damage;
    if(hp>max)hp=max;
    return hp<min;
}

//使用
main(){
    int hp = 2500;
    AddHp<2000,1000>(hp,100);
}

用非类型参数处理固定大小的数组

template <typename T1,short count>
T1 ave(T1(&ary)[count])
{
    T1 all{};
    for(int i = 0;i < count;i++){
        all+=ary[i];
    }
    return all/count;
}

//使用
main(){
    int a[5]{1,2,3,4,5};
    cout<<ave(a); //自动推断出了 count = 5
}

函数模板的本质

万能排序工具

#include<iostream>
//万能排序模板

template <typename T1>
void Sort(T1* arr, unsigned count, bool bigSort = true) {
	for (size_t i = 1; i < count; i++) {
		for (size_t i = 1; i < count; i++) {
			bool bcase = bigSort ? arr[i] > arr[i - 1] : arr[i] < arr[i - 1];
			if (bcase) {
				std::swap(arr[i], arr[i - 1]);
			}
		}
	}
}

//遍历输出
void show(int* arr,unsigned count) {
	for (size_t i = 0; i < count; i++) {
		std::cout << arr[i] << "  ";
	}
	std::cout << std::endl;
}

int main() {
	int a[5]{ 2302,5212,3654,9740,5200 };
	show(a, 5);
	std::cout << std::endl;
	Sort(a, 5);
	show(a,5);
	return 0;
}
//利用函数模板实现以下函数
//能够给 数组内的元素自动排序
/**
int a[5]{2302,.5212,3654,9740,5200}
sort(a,5);



*/