函数的重载，默认参数，占位参数
大家在学习函数的时候是否对函数的默认参数、函数的重载、函数的占位参数有一些疑惑呢。我根据自己的学习，整理了一些关于函数部分的知识，希望能够帮到大家解答疑惑。因为本人目前学识有限。如果文中有啥错误，欢迎批评指正。
目标人群：大一大二计算机专业的小伙伴，打算考计算机二级的同学，对函数的使用仍存在一些疑惑的小伙伴。
1.函数的默认参数
函数的默认参数是指，可以给函数的参数赋值
语法如下：
返回类型 函数名（参数a，参数b=默认值）{}
给函数的参数赋值的时候要注意的事项
1.从已经赋值的这个参数的位置起，从左到右每个参数都要赋值
eg：
void test(int a,int b=1,int c=1){
}这是正确的
void test(int a,int b=1,int c){
} 这是错误的，会报错
2.如果函数声明的时候参数已经赋值，那么实现函数，也就是函数体中不能再赋值
eg:
void test(int a=1,int b=1,int c=1);
void test(int a=2,int b=2,int c=2)
{
};
这样写是错误的，会发生运行错误，因为编译器不知道，它到底是用声明的默认值还是函数体的默认值
3.在调用函数的时候，可以省略已经赋值的参数，也可以不省略，如果不省略，形参的具体值是实参而非是默认值
eg：
void test(int a,int b=1,int c=1)
{
cout<<a+b+c<<endl;
};
int main()
{
test(1);结果是3
test(2,2,2);结果是6而不是4
}
完整的代码列子
#include<iostream>
using namespace std;
void Test1(int a, int b, int c)//普通的函数参数形式
{
cout << a + b + c << endl;
}
void Test2(int a, int b = 2, int c = 2)//给函数的形参赋值，默认参数
{
cout << a + b + c << endl;
}
//注意事项：
void Test3(int a=1, int b=1, int c=1);//函数声明
//void Test4(int a, int b = 1, int c);//从赋值了的那个参数起，从左到右的参数都要赋值，不要就会报编译错误
int main()
{
Test1(1, 1, 1);//三个参数都要写完
Test2(1);//因为已经有了默认参数，所以能够省略后面的参数传参
Test2(1, 1, 1);//当然也可以填完，思考一下此时输出的结果是3还是5？
//Test3();
}
void Test3(int a=2, int b=2, int c=2)//函数声明用了默认值，函数实现的时候就不能再有不能够重写函数声明的默认参数，不然会发生运行错误。
{
cout << a + b + c << endl;
}
2.函数的重载
函数的重载，是多态思想的一种体现
意思是用同一个函数名，通过给函数传递不同的参数的，让其实现不同的功能。
函数重载的三个条件（重点看第二、第三个条件）
1.必须要在同一个作用域下面
1.1我们在编程的时候，绝大多时候使用的函数都是全局函数，也就是在main函数之外定义的函数。但是后面也会有在其他作用域里面的函数。
所以函数重载的三个条件之一：必须要在同一个作用域内（这一点，初学者可以先不管，因为初学遇到的都是全局函数）
eg：
static void test();
void test(int a);
两个函数虽然名字一样，但是作用域不同，所以是构不成重载的。
2.函数的名称必须相同
void a();
void b(int a);
两个函数的名字不同，无法构成重载。
3.函数的参数个数不同，类型不同，顺序不同
3.1个数不同
void test(int a);
{
cout<<a<<endl;
}
void test(int a,int b);
{
cout<<b<<endl;
}
构成了函数的重载
int main()
{
test(1);调用第一个函数
test(1,1);调用第二个函数
}
3.2类型不同
void test(int a);
{
cout<<a<<endl;
}
void test(double a);
{
cout<<b<<endl;
}
构成了函数的重载
int main()
{
test(1);调用第一个函数
test(3.14159);调用第二个函数
}
3.3顺序不同
void test(int a,double b);
{
cout<<a<<endl;
}
void test(double a,int b);
{
cout<<b<<endl;
}
!!!!注意，顺序的不同是指类型的顺序!!!!!
构成了函数的重载
int main()
{
test(1,3.1415);调用第一个函数
test(3.1415,1);调用第二个函数
}
以上就是函数重载的三个条件，要注意的是个数不同、类型不同、顺序不同、说的全都是数据类型！
eg
void test(int a,int b);
void test(int c,int d);
没有构成重载
void test(int a,int b);
void test(int b,int a);
没有构成重载
代码的完整例子
#include<iostream>
using namespace std;
void t1()
{
cout << "1" << endl;
}
void t1(int a)//参数的个数不同
{
cout << "2" << endl;
}
void t1(double a)//参数的类型不同
{
cout << "3" << endl;
}
void t1(int a,double b)
{
cout << "4" << endl;
}
void t1(double a,int b)//参数的顺序不同
{
cout << "5" << endl;
}
//上面所展示的函数全部是全局函数，在同一个作用域内，且名字相同，而且参数的内容全部满足条件
int main()
{
t1();//这时候，我们调用函数的时候，函数名是不变的我们只要填写不同的参数就能够调用同一个函数名下的不同功能
t1(1);
t1(2.1);
t1(1, 2.1);
t1(2.1, 1);
return 0;
}
3.函数重载的注意事项
函数重载容易犯的错误
1.函数的返回值是不能够作为重载的条件的。
void fun()
int fun()
这样是构不成重载的
2.引用作为重载
引用是可以作为函数的重载，下面，大家可以当作一个特殊的情况来记
void test(int &a);
void test(const int &a);
int main()
{
int a=10;
test(a);//调用的是第一个函数，a可读可写，函数中的参数也是可读可写的
const b=20;
test(10);//调用的是第二个函数，编译在遇到10的时候，会自动生成，const int temp=10,&a=temp;
test(b);//调用的是第二个函数，b只可读不可写，对应的函数的参数的a也是只可读，不可写。
}
可能很多人觉得上面这个两个参数的类型都是int，但是，这是能构成重载的，因为是引用的重载，而且下面的函数加了const关键字。如果大家觉得难以理解，可以先把引用的重载当作特殊的列子记住
3.重载参数默认值
在函数重载的时候，如果函数的参数有默认值，在函数调用的时候不注意的话会很容易出现二义性
void test(int a,int b=100)
{
cout<<1<<endl;
}
void test(int a)
{
cout<<2<<endl;
}
此时两个函数右键构成了重载的条件，参数的个数不同
int main()
{
test(10);//这时候就会出现二义性了，会报错，因为根据函数的参数如果有默认值，调用的时候是可以省略实参的填写的，那么编译器就不知道到底改用哪一个函数了
}
解决办法：1.在使用函数的重载的时候，不给函数的参数赋默认值。
4.函数的占位参数
占位参数，对大多数初学者来说，在c++的初学者阶段，占位参数基本没啥用。
语法：
返回类型 函数名 （数据类型 变量，数据类型）
void test(int a,int)后面这个int就是占位参数
注意事项：
1.占位参数同样是可以赋初值的，同样是赋值之后可以省略
eg：
void test(inta,int=123212){
}
int main()
{
test(1);
}
#include<iostream>
using namespace std;
void test(int a, int)
{
cout << "这是一个占位参数" << endl;
}
void test2(int a, int = 99)//占位符可以赋默认值，这样调用的时候可以省略
{
cout << "这还是一个占位参数" << endl;
}
int main()
{
test(10, 10);
test2(10);
return 0;
}