【C++入门必备知识：缺省参数+函数重载+函数名修饰规则】

①.缺省参数

Ⅰ.概念

当声明或定义函数时，为函数的参数指定一个缺省值，也叫做默认值。
规则：
当调用该函数时，如何没有没有指定实参则采用改形参的默认值。
当调用该函数时，指定实参，那就使用传过来的实参。

通俗的说就是：
没有传参时，使用参数的默认值
传参时，使用指定的实参

void fun(int n=10)
{
	cout << n << endl;
}
int main()
{
	fun();//没有指定实参，则使用缺省参数
	fun(20);//指定实参
}

1.全缺省参数

全缺省参数，即函数形参都被指定为缺省值

using namespace std;
void fun(int a=1,int b=2,int c=3)
{
	cout << a<< endl;
	cout << b << endl;
	cout << c << endl;
}
int main()
{
	fun();//全缺省参数，形参全部指定为缺省值，不传实参
}

2.半缺省参数

半缺省参数，即函数形参部分被指定为缺省值

void fun(int a,int b=2,int c=3)
{
	cout << a<< endl;
	cout << b << endl;
	cout << c << endl;
}
void fun2(int a,int b, int c = 9)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
int main()
{
	fun(2);//部分缺省，部分形参指定为缺省值
	fun2(5, 6);
}

3.使用规则

• 1.传参是从左向右传，不能隔着传。
• 2.而缺省参数是从右到左缺省。
• 3.声明和定义不能同时给缺省
  为什么声明和定义不能同时给缺省呢？？？
  因为会出现这样的场景：当声明和定义的缺省参数不一致时，那编译器到底该用哪个缺省值呢？
• 4.准确的来说，只能在声明函数的时候来给缺省，定义时候不能给。
• 5.缺省值必须是常量或者全局变量
• 6.默认参数也叫缺省参数

4.应用场景再现

比如顺序表中有静态顺序表和动态顺序表。我们知道静态顺序表，写死了固定大小，很不好使，但动态顺序表又需要不断的扩容，扩容操作是需要消耗效率的。所以我们可以利用缺省参数，来对顺序表的默认大小进行缺省，当我们知道要插入多少数据时，则指定传相对的大小，那顺序表一开始就会开辟那么大的空间，就不需要从一小块不断扩容了。而当我们不知道要插入的数据时，那么就按照给定的默认值(缺省值)来进行开辟空间。

typedef struct SQList
{
	int* a;
	int size;
	int capacity;
}SQList;
void SQInit(SQList *s,int defalutCapacity=4)
{
	s->a = (int*)malloc(sizeof(SQList) * defalutCapacity);
	if (s->a == NULL)
	{
		perror("malloc");
	}
}
int main()
{
	SQList s;
	SQInit(&s);//如果不知道要插入多少数据，那就按照默认值4来
	SQInit(&s, 100);//如果知道要插入多少数据，那么直接就开辟这么大的空间，不需要不断的扩容到100
}

②.函数重载

C语言不允许存在同名函数，但C++允许存在同名函数，这么做的原因是用来处理实现功能类似数据类型不同的问题。
那C++是如何做到让同名函数同时存在的呢？

Ⅰ.概念

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参( |参数个数|或类型|或类型顺序|)不同。

1.参数个数不同

//参数个数不同
int Add2(int left, int mid,int right)//3个参数
{
	return left+mid + right;
}
int Add(int left, int right)//2个参数
{
	return left + right;
}


int main()
{
	printf("%d\n", Add(1, 1));//编译器会自动识别使用哪一个函数的
	printf("%d\n", Add2(1,2,3));
}

参数个数不同：

void f()
{
	cout << "f()" << endl;
}
void f(int a)
{
	cout << "f(int a)" << endl;
}

不过要注意的是下面这个例子

void f()
{
	cout << "f()" << endl;
}
void f(int a=0)
{
	cout << "f(int a)" << endl;
}

你觉得它构成函数重载吗？
从定义的角度来说，它确实是一个没有参数，一个有一个参数，它们参数个数不同，函数名相同，所以是构成函数重载的。但有没有什么问题呢？
你看，第二个函数的参数被缺省了，也就是相当于当函数传参时，传不传都无所谓，传参数，那就使用这个实参，如果不传，那就使用缺省参数。那么问题来了，如果我们不传参数，到底调用的是第一个函数，还是调用第二个函数呢？
第一个函数没有参数，如果我们不传参正常来说就应该调用第一个，但第二个同名函数的参数被缺省了。所以就会出现
调用不明确问题。

2.参数类型不同

//参数类型不同
int Add(int left, int right)//int 类型
{
	return left + right;
}
double Add(double left, double right)//double 类型--注意这里返回值是double ，不需要管返回值类型
{
	return left + right;
}
int main()
{
	printf("%d\n", Add(1, 1));
	printf("%f\n", Add(1.1, 1.1));//编译器会自动识别数据类型，并且使用相应的函数
}

3.参数类型顺序不同

void fun1(int a, char c)
{
	cout << a << " " << c << endl;
}
void fun1(char c, int a)
{
	cout << c << " " << a << endl;
}
int main()
{
	fun1(1,'x');
	fun1('w', 6);
}

要明确注意的是这里是类型顺序，而不是变量顺序。
比如下面这个坑

void fun1(int a, char c)
{
	cout << a << " " << c << endl;

}
void fun1(int c, int a)
{
	cout << c << " " << a << endl;
}

你觉得构成重载吗？
当然不构成了，我们要严格按照定义，是类型顺序不同如果是上面这个例子，那我要传fun1(1,'x');到底调用的是哪一个函数呢，是上面的还是下面的呢？所以是有歧义的。

c++虽然允许同名函数并且会自动识别变量类型
但要严格遵守函数重载的规则才可以。

4.对返回值没有要求

函数重载对函数的返回值是没有要求的。
返回值没有要求，但是当后面的要求不符合是，仍然不能构成重载(函数参数类型不同，函数参数的个数不同，函数类型顺序不同)
返回值没有要求 --不构成重载 —无法使用

int Add(int left, int right)
{
 cout << "int Add(int left, int right)" << endl;
 return left + right;
}
double Add(double left, double right)
{
 cout << "double Add(double left, double right)" << endl;
 return left + right;
}

比如这样，两个同名函数符合参数类型不同，所以构成重载。虽然它们返回值不同，但函数重载对返回值没有要求。

③.函数名修饰规则

为什么C语言不支持函数重载，而C++支持重载呢？
C++又是如何支持的呢？
这其中就要涉及程序的【编译与链接过程】与【函数名修饰规则】

假设一个工程里有三个文件，一个是专门声明各函数的文件，一个是专门定义各函数的文件，一个是用来测试这些函数功能的文件。

我们知道一个程序要通过预编译，编译，汇编，链接四个部分才可以生成可执行程序。
而各个阶段的处理也不相同。
大体是就是在预编译阶段，在声明和定义的两个文件里包含的头文件会被展开，宏会被替换，还有注释会被去掉。
然后各生成一个带 .i的文件。在编译阶段会进行检查语法，生成汇编代码，并生成一个带.s的文件。
汇编阶段会进行将汇编代码转化为机器指令，生成一个符号表，并生成一个带.o的文件，最后在链接阶段，会将符号表合并和重定位，将两个带.o文件链接成一个可执行程序。

根据函数栈帧的创建和销毁，我们知道当调用一个函数时，会执行一个call的汇编代码。call后面就是函数的地址。然后就会使用jump跳进调用的函数里。

而在实际的项目中通常是由多个头文件和多个源文件。
比如在test.c文件里调用了定义.c文件里的函数A，在链接之前，test.o文件里是没有函数A的地址的，因为函数A的地址在定义.c文件里。

那么test.c程序如何执行呢？
在链接阶段会解决这个问题，链接器看到test.o调用函数A，但是又没有函数A的地址，它就会到定义.o符号表中去找函数A的地址，然后重定位到一起。

我们可以这样比喻：将在.h头文件里声明的看成一种承诺

test.c想要买房，还差钱，向好兄弟.h文件借钱，好兄弟.h满口答应。给定了test.c承诺。
test.c有了承诺，它就敢买房了，这个过程是合法的。所以不会报错的。
但要真正的买到房，还需要.h兑现承诺，而如果.h找到定义的文件就可以兑现承诺了。
所以test.c要执行起来就需要找到定义来兑现承诺。
链接的作用就是：找到定义(兑现承诺)。

那还有一个问题，链接器是如何找定义的呢？是找哪个定义的呢？
是使用哪个名字定义的呢？
在不同的编译器有不同的函数名修饰规则。

Ⅰ.C/C++的不同

我们举例gcc和g++的例子。

• 1.C语言编译器编译结果：

我们发现gcc的函数修饰后名字是不改变的。

• 2.C++编译器编译器结果：

而在g++的函数修饰后变成了【_Z+函数长度+函数名+类型首字母】

• 3.结论：采用C语言编译器编译后，函数名没有改变，而采用C++编译器编译后，函数名经过函数修饰发生改变，并且跟函数的参数类型，参数个数等有关。

• 4.通过这里我们就可以理解C语言没有办法支持重载了，因为C编译器，在编译后，同名函数没有办法区分，而C++经过函数修饰规则，根据函数参数的类型，参数的个数不同而改变函数的名字进行区分，只要参数不同，修饰后的函数名就不一样，这样就支持重载了。

• 5.如果两个函数函数名和参数都是一样的，但是函数返回值不一样，这是不构成重载的，因为重载的定义没不包括返回值。编译器没有办法区分。