C++基础知识之"函数重载"

发表于 | 分类于
在C++中重载，重写，重定义，不要迷惑哟！

fengjingtu

函数重载概念

函数重载的概念

用同一个函数名定义不同的函数

当函数名和不同的参数搭配时函数的含义不同

函数重载的判断标准

函数重载至少满足下面的一个条件：

参数个数不同

参数类型不同

参数顺序不同

函数返回值不是函数重载的判断标准

初学者容易混淆这一点。

函数重载的调用准则

编译器调用重载函数的准则

将所有同名函数作为候选者

尝试寻找可行的候选函数

精确匹配实参

通过默认参数能够匹配实参

通过默认类型转换匹配实参

匹配失败

最终寻找到的可行候选函数不唯一，则出现二义性，编译失败。

无法匹配所有候选者，函数未定义，编译失败。

注意

重载函数在本质上是相互独立的不同函数（静态链编）

重载函数的函数类型是不同的

函数返回值不能作为函数重载的依据

函数重载是由函数名和参数列表决定的。

函数重载是发生在一个类中里面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


void overload_demo1(int a)
{
	printf("a=%d\n", a);
	return;
}
void overload_demo1(float a)
{
	printf("a=%f\n", a);
	return;
}
void overload_demo1(int a, int b)
{
	printf("a=%d,b=%d\n", a, b);
	return;
}
void overload_demo1(const char *s)
{
	printf("s=%s\n", s);
	return;
}

int main_demo1()
{
	int a = 1;
	int b = 2;
	float c = 1.3;
	double d = 1.5;
	char *s = "hello";
	overload_demo1(a);
	overload_demo1(a, b);
	overload_demo1(c);
	//overload_demo1(d);//error
	overload_demo1(s);
	overload_demo1((float)d);
	overload_demo1((int)d);
	//overload_demo1((char *)d);//error
	return 0;

}

函数重载遇上函数默认参数

学习函数重载有两个难点：重载函数和默认函数参数混搭 重载函数和函数指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int func(int a, int b, int c = 0)
{
	return a * b * c;
}

int func(int a, int b)
{
	return a + b;
}


int main()
{
	int c = 0;

	c = func(1, 2); // 存在二义性，调用失败，编译不能通过 
	return 0;
}
*/

函数重载与函数指针结合

当使用重载函数名对函数指针进行赋值时

根据重载规则挑选与函数指针参数列表一致的候选者

严格匹配候选者的函数类型与函数指针的函数类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
void overload_demo2(int a)
{
	printf("a=%d\n", a);
	return;
}
void overload_demo2(float a)
{
	printf("a=%f\n", a);
	return;
}
void overload_demo2(int a, int b)
{
	printf("a=%d,b=%d\n", a, b);
	return;
}
void overload_demo2(const char *s)
{
	printf("s=%s\n", s);
	return;
}
typedef void(*OVERLOAD)(int a); // int(int a)

int main_demo()
{
	int a = 1;
	int b = 2;
	float c = 1.3;
	double d = 1.5;
	char *s = "hello";

	OVERLOAD p = overload_demo2;

	p(a);
	//p(a,b);
	p(c);
	p(d);//error
		 //p(s);
	p((float)d);
	p((int)d);
	//p((char *)d);//error
	//typedef void(*OVERLOAD)(int a);
	//必须只有一个参数，且能够自动强转相近类型
	return 0;
}