C++函数默认参数， 函数重载， 函数模板

一：C++函数默认参数

注意一下几点就可以

1：默认参数的指定在函数的声明，并不是在定义

2：必须从右到左添加默认参数，即要为某个参数设置默认值，则必须为它

      右边的所有参数提供默认值

代码：    

/*默认函数参数*/
#include<iostream>
using std::cin;
using std::cout;
using std::endl;

int Max(int a, int b = 0); //函数声明的时候指定默认值 
/*
假设这个函数有三个参数， Max(int a, int b = 0, int c);
这样的声明肯定是不行的，没有遵守第二点
*/ 
int main()
{
	cout << Max(-1) << endl;
	cout << Max(2, 3) << endl;
	return 0;
}

int Max(int a, int b)
{
	if(a > b) return a;
	else return b;
}

二：函数重载，一个多态的概念

重载也应注意几点

1：函数重载的关键是函数的参数列表，也称为函数特征标

2：返回值不同并不构成重载

3：编译器在检查函数特征标时，把类型引用和类型本身视为同一特征标

4：在进行对有函数重载的时候，注意二义性的发生,后面的代码会有说明

代码：

/*函数重载*/ 
#include<iostream>
using std::cin;
using std::cout;
using std::endl;
/*
int Max(int a, int b);
double Max(int a, int b);
如果这样定义这两个函数，并不会构成重载， 程序会报重复定义的错误 
*/

/*
 int Max(char bits);
 int Max(char &bits);
 并不构成重载 
*/

/*
print(long a, int b);
print(double a, int b);
如果你在主函数想下面这样调用 ，就会报二义性错误
int year; print(year, 6) ;
编译器分不出该调用哪个函数 
*/ 

int Max(int a, int b);
double Max(double a, double b);
int main()
{
	cout << Max(2, 3) << endl;
	cout << Max(2.3, 1.0) << endl; 
	return 0;
}

int Max(int a, int b)
{
	return a > b ? a : b; 
}

double Max(double a, double b)
{
	return a > b ? a : b; 
}

三：函数模板

函数的模板提高了代码的可重用性，这个特性很好，也挺复杂的

代码：一个简单的例子

#include<iostream>
using std::cin;
using std::cout;
using std::endl;

template<typename T>
int swap(T &a, T &b);

int main()
{
	int a1 = 2;
	int b1 = 3;
	swap(a1, b1);
	cout << a1 << " " << b1 << endl;
	
	double a2 = 2.3, b2 = 3.4;
	swap(a2, b2);
	cout << a2 << " " << b2 << endl;
	
	return 0;
}

template<typename T>
int swap(T &a, T & b)
{
	T temp = a;
	a = b;
	b = temp;
	return 0;
}

函数模板还有一个特性，可以显式具体化，在某种场合可以使用

代码：

/*
模板还有一个特性就是可以显式具体化 
对于一个结构体，我们可以为它写个交换的模板，但是我们只是想
交换结构体中某些成员的值时，显式具体化就体现出其好处
具体的可以看代码 
*/
#include<iostream>
#include<stdio.h>
#include<string.h>
using std::cin;
using std::cout;
using std::endl;

struct people
{
	char name[10];
	int age;	
	double salary;
}; 

template <typename T>
int swap(T &a, T &b); //fuction prototype

template<>int swap<people>(people &p1, people &p2);
//显式具体化对于同一个类型， 优先性高于普通函数的模板
//程序的结果也证明了这一点
 
void show(people a)
{
	cout << a.name << " " << a.age << " " << a.salary << endl;
}
int main()
{
    int A1 = 20, A2 = 30;
    swap(A1, A2);
    cout << A1 << " " << A2 << endl; 
	people a1 = {"Bob", 20, 10.3};
	people a2 = {"Mary", 21, 20.4};
	swap(a1, a2);
	show(a1); show(a2);
	
	
	return 0;
}

template<typename T>
int swap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp; 
	return 0;
}

template<> int swap<people>(people &p1, people &p2)
{
	char p[10];
	strcpy(p, p1.name);
	strcpy(p1.name, p2.name);
	strcpy(p2.name, p);
	return 0;
}

模板函数还有一个特性：显式实例化，有兴趣的同学可以研究一下

感觉用的不多