1 初识重载
函数重载指的是用同一个函数名定义不同的函数，当函数名和不同的参数搭配时函数的含义不同。
编程实验：函数重载初探
// 6-1.c
#include <stdio.h>
#include<string.h>
int func(int x)
{
return x;
}
int func(int a, int b)
{
return a + b;
}
int func(const char* s)
{
return strlen(s);
}
int main(int argc, char *argv[])
{
printf("%d\n", func(3));
printf("%d\n", func(3, 4));
printf("%d\n", func("Hello"));
return 0;
}
编译运行：
$ g++ 6-1.c -o 6-1
$ ./6-1
3
7
5
可以看出函数名和不同的参数搭配时函数的含义不同，调用的函数不同。实现同一函数名定义不同函数。
1.1 重载条件
函数重载至少满足下面的一个条件：
- 参数个数不同
- 参数类型不同
- 参数顺序不同
下面两个函数的参数顺序不同，所以是重载函数。
1.2 避免默认参数碰到函数重载
当默认参数碰到函数重载会发生什么呢？我们通过实验来说明：
直接看代码，有两个 func() 函数，第一个 func() 函数有三个 int 型参数，第三个参有默认值。第二个 func() 函数有两个 int 型参数。
// 6-2.c
#include<stdio.h>
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 = func(1, 2);
return 0;
}
编译结果如下：
$ g++ 6-2.c -o 6-2
6-2.c: In function ‘int main()’:
6-2.c:13:22: error: call of overloaded ‘func(int, int)’ is ambiguous
int c = func(1, 2);
^
6-2.c:3:5: note: candidate: int func(int, int, int)
int func(int a, int b, int c = 0)
^~~~
6-2.c:7:5: note: candidate: int func(int, int)
int func(int a, int b)
^~~~
编译器报错，说 func() 函数调用不明确，两个函数都满足调用条件，编译器不知道调用谁，直接报错。
1.3 编译器调用重载函数的准则
- 将所有的同名函数作为候选者
- 尝试寻找可行的候选函数
- 精确匹配实参
- 通过默认参数能够匹配实参
- 通过默认类型转换匹配实参
- 匹配失败
- 最终寻找到的候选函数不唯一，有二义性
- 无法匹配候选者
2 函数重载的本质
函数重载是函数名和参数列表决定的：
- 重载函数在本质上是相互独立的不同函数，其函数类型不同
- 函数返回值不能作为函数重载的依据
// 6-3.c
#include<stdio.h>
int add(int a, int b) // 函数类型：int(int, int)
{
return a + b;
}
int add(int a, int b, int c) // 函数类型：int(int, int ,int)
{
return a + b + c;
}
int main()
{
printf("%p\n", (int(*)(int, int))add);
printf("%p\n", (int(*)(int, int, int))add);
return 0;
}
上面的代码将两个重载函数的地址打印出来。
$ g++ 6-3.c -o 6-3
$ ./6-3
0x560c03a8c64a
0x560c03a8c65e
可以看出两个重载函数的地址完全不同，说明这是两个独立的函数。
3 重载与指针
将重载函数名赋值给函数指针时：
- 严格匹配候选者的函数类型与函数指针的函数类型，也就是数需要匹配参数个数，参数类型，参数顺序和返回值类型
直接看代码，下面的函数指针将保存哪个函数的地址呢？
// 6-4.c
#include<stdio.h>
#include<string.h>
int func(int x)
{
return x;
}
int func(int a, int b)
{
return a + b;
}
int func(const char* s)
{
return strlen(s);
}
typedef int(*PFUNC)(int a);
int main(int argc, char* argv[])
{
int c = 0;
PFUNC p = func;
c = p(1);
printf("c = %d\n", c);
return 0;
}
定义函数指针 PFUNC，参数类型 int，返回值为 int，则将 PFUNC 指向 函数 func()，将保存那个函数的地址呢？
编译运行：
$ g++ 6-4.c -o 6-4
$ ./6-4
c = 1
可以看出函数指针保存的是函数 int func(int x); 的地址。
如果将代码 6-4.c 的第 16 行改为 typedef void(*PFUNC)(int a); 或者 typedef double(*PFUNC)(int a); 重新编译
编译器报错，没有匹配的函数与函数指针相对应。
typedef void(*PFUNC)(int a); 的函数类型为 void(int, int)
typedef double(*PFUNC)(int a); 的函数类型为 double(int, int)
这两个函数类型与所有的 func() 函数都不匹配。
注意：
- 函数重载必然发生在同一作用域中
- 编译器需要用参数列表或函数类型进行函数选择
- 无法直接通过函数名得到重载函数的入口地址
4 C++ 和 C 相互调用
- C++ 编译器能够兼容 C 语言的编译方式
- C++ 编译器优先使用 C++ 编译的方式
- extern 关键字能强制让 C++ 编译器进行 C 方式的编译
extern "C"
{
// do C-style compilation here
}
编程实验：C++调用 C 函数
// add.c
#include "add.h"
int add(int a, int b)
{
return a + b;
}
// add.h
int add(int a, int b);
首先将上面的代码用 gcc 编译成汇编器处理之后，链接器处理之前的 .o 文件，生成 add.o 文件。
$ gcc -c add.c -o add.o
// main.cpp
#include<stdio.h>
#include "add.h"
int main()
{
int c = add(1, 2);
printf("c = %d\n", c);
return 0;
}
在 main.cpp 中调用 add.o 中的 add 函数，编译如下：
$ g++ main.cpp add.o -o main
/tmp/cccdww4k.o：在函数‘main’中：
main.cpp:(.text+0x13)：对‘add(int, int)’未定义的引用
collect2: error: ld returned 1 exit status
编译器报错，说 add 函数没定义，这是因为 add.o 是以 C 语言的规则编译的，以 C++ 规则找不到编译后的文件名。所以在 C++ 编译器中编译 main.cpp 中的 #include “add.h” 应该以 C 语言的规则进行编译。
解决方案：
但是，如何保证一段 C 代码只会以 C 的方式被编译？
- __cplusplus 是 C++ 编译器内置的标准宏定义，用于确保 C 代码以统一的 C 方式被编译成目标文件
将 main.cpp 更改如下：
// main.cpp
#include<stdio.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "add.h"
#ifdef __cplusplus
}
#endif
int main()
{
int c = add(1, 2);
printf("c = %d\n", c);
return 0;
}
编译运行：
$ g++ main.cpp add.o -o main
$ ./main
c = 3
这样，无论是 C 编译器还是 C++ 编译器，都可以运行。
注意事项：
- C++ 编译器不能以 C 的方式编译重载函数，C 中没有重载
- C++编译方式将函数名和参数列表编译器目标文件，C 编译方式只将函数名作为目标名进行编译‘
5 小结
1、重载使用一个函数定义不同的函数
2、重载本质为相互独立的不同的函数
3、C++ 通过函数名和函数参数确定函数调用
4、extren 关键字能够实现 C 和 C++ 的相互调用
5、编译方式决定符号表中的函数名的最终目标名
