目录
一、缺省参数
1.1缺省参数的概念
缺省参数：声明或定义函数时为函数的参数指定一个缺省值，在调用函数时如果没有指定实参，那么将会采用该函数的缺省值，否则使用指定的实参。
namespace lx
{
void print(int a=1)
{
cout << a << endl;
}
}
using namespace lx;
int main()
{
print();
print(20);
return 0;
}
1.2缺省参数的分类
缺省参数分为全缺省参数和半缺省参数
①全缺省参数
全部的形参都给指定的缺省值
namespace lx
{
void print(int a=1,int b=2,int c=3)
{
cout << a << ',' << b << ',' << c << endl;
}
}
using namespace lx;
int main()
{
print();
print(20);
print(20, 21);
print(20, 21, 22);
return 0;
}
如果不传参数的话，那么就会使用缺省值，如上面的结果
②半缺省参数
部分形参给指定的缺省值
namespace lx
{
void print(int a,int b=2,int c=3)
{
cout << a << ',' << b << ',' << c << endl;
}
}
using namespace lx;
int main()
{
print(20);
print(20, 21);
print(20, 21, 22);
return 0;
}
这里需要注意的是，缺省值只能从右往左给，否则将会报错，给的时候不能跳着给，传参的时候也不能跳着传，否则会报错，不符合语法，就像下图的传参方式是不合法的
注：
1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现
3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）5.缺省参数必须是常量或全局变量
二、函数重载
2.1函数重载的概念
函数重载：C++中允许在同一作用域中存在多个功能类似的同名函数，这些同名函数的形参列（参数类型、顺序、个数）不同，多数用来处理实现功能类似但参数类型不同的问题
2.2形参列表不同举例
①参数类型不同
void print(int a, int b = 2, int c = 3)
{
cout << a << ',' << b << ',' << c << endl;
}
void print(double a, int b = 2, int c = 3)
{
cout << a << ',' << b << ',' << c << endl;
}
void print(double a, double b = 2, double c = 3)
{
cout << a << ',' << b << ',' << c << endl;
}②参数类型顺序不同
void print(double a, int b = 2, char c = 'A')
{
cout << a << ',' << b << ',' << c << endl;
}
void print(int a, double b = 2, char c = 'A')
{
cout << a << ',' << b << ',' << c << endl;
}
void print(int a, char b = 'A', double c = 2)
{
cout << a << ',' << b << ',' << c << endl;
}③参数个数不同
void print(int a)
{
cout << a << endl;
}
void print(int a, char c = 'A')
{
cout << a << ',' << c << endl;
}
void print(double a, int b = 2, char c = 'A')
{
cout << a << ',' << b << ',' << c << endl;
}2.3C++支持函数重载的原理----名字修饰
为什么C++支持函数重载而C语言不支持呢？
在C/C++中运行起来需要经历：预处理、编译、汇编、链接 四个阶段
1. 实际项目通常是由多个头文件和多个源文件构成，而通过C语言阶段学习的编译链接，我们
可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标
文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么
怎么办呢？
2. 所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就
会到b.o的符号表中找Add的地址，然后链接到一起。
3. 那么链接时，面对Add函数，链接接器会使用哪个名字去找呢？这里每个编译器都有自己的
函数名修饰规则。
4. 由于Windows下vs的修饰规则过于复杂，而Linux下g++的修饰规则简单易懂，下面我们使
用了g++演示了这个修饰后的名字。
5. 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度
+函数名+类型首字母】
int Add(int a,int b)
{
return a + b;
}
void func(int a, double b,int* p)
{
}
int main()
{
Add(1, 2);
func(1, 2, 0);
return 0;
}采用C语言编译器编译后结果
结论：在Linux下，采用gcc编译完成后，函数名字的修饰没有发生改变
采用C++编译器编译后结果为：
结论：在Linux下，采用g++编译器编译以后，函数名字的修饰发生了改变，编译器将函数参数类型信息添加到了修改后的名字中
Windows下的函数名修饰规则较为复杂，但是和Linux函数名修饰都有相同的作用，这就不过多述说了。
通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修
饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办
法区分。
三、引用
3.1引用的概念
引用不是新定义一个变量，而是给已存在的变量取一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量使用同一块内存空间
比如：罗翔老师，在网络上人们都称他为“法外狂徒张三”
引用格式： 类型 & 引用变量名（或类名）= 引用实体
int main()
{
int a = 0;
int& a1 = a;//定义引用类型
cout << a << endl;
cout << a1 << endl;
printf("%p\n", &a);
printf("%p\n", &a1);
return 0;
}
可以发现它们使用同一块空间，值相同
注意：引用类型必须和引用实体是同种类型的
3.2引用特性
①引用在定义时必须初始化
int main()
{
int a = 0;
//int& a1; //这条语句会报错，不符合语法
int& a1 = a;
int b = 10;
a1 = b; //表示把b的值赋给a1
//a1值的改变也会改变a的值
cout << "a1的值:" << a1 <<' ' << "a的值:" << a << endl;
return 0;
}②一个变量可以有多个引用
int main()
{
int a = 0;
int& a1 = a;
int& b = a;
int& c = a;
printf("%p %p %p %p", &a, &a1, &b, &c);
return 0;
}
③引用一旦引用一个实体，将不能再引用其他实体
3.3常引用
int main()
{
const int a = 10;
//int& a1 = a; //该语句会报错，a为常量，a的权限被放大了
const int& a1 = a;
//int& b = 10; //该语句会报错
const int& b = 10;
double c = 10.0; //只是把值赋给c,不会报错
//int& c1 = c; //该语句会报错
double& c1 = c;
const int& c2 = c; //隐式类型转换出了一个临时变量，临时变量具有常性
return 0;
}注：引用时，变量的权限可以被缩小但不能被放大，当引用类型不同时，会发生隐式类型转换，而转换出的临时变量具有常性，所以需要用const来修饰
3.4使用场景
①做参数
此时传的参数是传引用不会开辟新的空间，引用改变也会改变被引用实体
void Swap(int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
}②做返回值
int& count()
{
static int n;
++n;
return n;
}下面的代码会返回什么呢？
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1, 2) is :" << ret << endl;
return 0;
}
可以发现，此时返回的是一个随机值，这显然不是我们需要的值。
看到这肯定会有疑惑，为什么不是我们需要的值呢？
原因：变量c是在栈上定义的，当函数调用完后，函数栈帧会销毁，变量c自然也被销毁了，使用权限还给了系统。而②中的n没被销毁是因为n是在全局变量区定义的，n的生命周期不随着栈帧的销毁而结束，所以②中返回的不是随机值
注意：如果函数返回时，出了函数作用域，返回对象还没被销毁（还没还给系统），则可以使用引用返回，否则只能使用传值返回。
3.5传值返回和传引用返回的性能比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直
接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效
率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
// 以值作为函数的返回值类型
size_t begin1 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc1();
size_t end1 = clock();
// 以引用作为函数的返回值类型
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc2();
size_t end2 = clock();
// 计算两个函数运算完成之后的时间
cout << "TestFunc1 time:" << end1 - begin1 << endl;
cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
TestReturnByRefOrValue();
return 0;
}
可以发现，传值返回的效率比较低，传引用返回的效率很高。它们的返回效率相差甚大。
3.6引用和指针的区别
①在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
int main()
{
int a = 10;
int& a1 = a;
cout << &a1 << " " << &a << endl;
return 0;
}
②在底层实现上实际是有空间的，因为引用是按照指针方式来实现的
int main()
{
int a = 10;
int& a1 = a;
a1 = 20;
int* pa = &a;
*pa = 20;
return 0;
}通过下面的汇编代码可以发现它们原理是一样的
引用和指针的不同点
1.引用概念上是给实体去一个别名，指针存储该实体的地址
2.引用在定义时必须初始化，指针没有要求
3.引用在初始化时引用一个实体后就不能再引用其他实体，而指针可以随时指向任何相同类型的实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全
今天的分享就到这里了，感谢支持，有不对的地方请帮忙指出来，谢谢咯。