C++函数的重载

什么是函数重载

    函数的重载能使我们定义多个同名函数，我们在调用时，编译器会根据函数特征标自动帮我们调用对应的函数。嗯，这个特性又是C++为了方便程序员，通过编译器帮我们干活，设计出来的一个东西。通过C和C++的对比，我们可以看到函数重载的这种特性是怎么提出来的。

实现原理

C的做法

    假设我们使用C要实现一个打印数字的功能，数值可能有多种类型，于是我们要给每一种类型写一个函数。

void printnum_char(char)
{
}
 
void printnum_short(short)
{
}
 
void printnum_int(int)
{
}
 
int main(void)
{
  char a=1;
  short b=1024;
  int c=655360;
  
  printnum_char(a);
  printnum_short(b);
  printnum_int(c);
}

这样做，有一些缺点：

• 我们在调用时，要时刻操心不同的参数类型，要选择正确的函数，如下面的例子，一不小心，就可能导致数据溢出。

  //如果不小心做了如下调用，short类型的b传给了char类型的参数，发生了截断，与预期不符，当然现在的IDE，编译器都比较强大了，会报警告
  printnum_char(b)

• 函数名包含了多余的区分信息，例如这里我以C语言的基本的数据类型做标记，这种信息和程序逻辑毫不相干。

C++的做法

void printnum(char)
{
}
 
void printnum(short)
{
}
 
void printnum(int)
{
}
 
int main(void)
{
  char a=1;
  short b=1024;
  int c=655360;
  
  printnum(a);
  printnum(b);
  printnum(c);
}

    C/C++都是强类型语言，因此变量在使用前类型已经明确了，这是由他们的语法规则确定的。那么一旦一个变量定义好，编译器就清楚变量的类型。如上，如果不同类型的变量作为参数传递给函数时，编译器也就有手段知道最佳匹配函数。具体实现原理可以看下上面C++代码的汇编代码：

g++ -S main.cpp -o main.asm

以下为汇编代码：

	.file	"main.cpp"
	.text
	.globl	_Z8printnumc
	.type	_Z8printnumc, @function
_Z8printnumc:
.LFB0:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	%edi, %eax
	movb	%al, -4(%rbp)
	nop
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	_Z8printnumc, .-_Z8printnumc
	.globl	_Z8printnums
	.type	_Z8printnums, @function
_Z8printnums:
.LFB1:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	%edi, %eax
	movw	%ax, -4(%rbp)
	nop
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE1:
	.size	_Z8printnums, .-_Z8printnums
	.globl	_Z8printnumi
	.type	_Z8printnumi, @function
_Z8printnumi:
.LFB2:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	%edi, -4(%rbp)
	nop
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE2:
	.size	_Z8printnumi, .-_Z8printnumi
	.globl	main
	.type	main, @function
main:
.LFB3:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$16, %rsp
	movb	$1, -7(%rbp)
	movw	$1024, -6(%rbp)
	movl	$655360, -4(%rbp)
	movsbl	-7(%rbp), %eax
	movl	%eax, %edi
	call	_Z8printnumc
	movswl	-6(%rbp), %eax
	movl	%eax, %edi
	call	_Z8printnums
	movl	-4(%rbp), %eax
	movl	%eax, %edi
	call	_Z8printnumi
	movl	$0, %eax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE3:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 9.4.0-1ubuntu1~20.04.2) 9.4.0"
	.section	.note.GNU-stack,"",@progbits
	.section	.note.gnu.property,"a"
	.align 8
	.long	 1f - 0f
	.long	 4f - 1f
	.long	 5
0:
	.string	 "GNU"
1:
	.align 8
	.long	 0xc0000002
	.long	 3f - 2f
2:
	.long	 0x3
3:
	.align 8
4:

可以看到，同样一个printnum函数，在汇编时，函数符号对应关系为：

_Z8printnumc <---> printnum(char)
_Z8printnums <---> printnum(short)
_Z8printnumi <---> printnum(int)

很明显c,s,i分别是char,short,int的开头字母。也就是说C++其实是通过编译器，帮我们按照C的方式实现了函数重载，把机械的事交给了工具（编译器）干。这样看来，函数的符号最终还是不一样的，编译器需要通过函数的原型，在汇编时给它重命名，以达到区分的目的，前面提到函数的特征标，就是用来提示编译器做区分的。特征标指：函数的参数类型，参数个数，参数顺序。观察一下汇编重命名重载函数的规律：

class A{};
class AB{};
void printnum(){}
void printnum(int*){}
void printnum(int){}
void printnum(A){}
void printnum(AB){}
void printnum(int, int){}
void printnum(int, char){}
char printnum(int, int, int){return '0';}

反汇编后，可以得到如下对应关系：

_Z8printnumv   <---> void printnum()
_Z8printnumi   <---> void printnum(int)
_Z8printnumPi  <---> void printnum(int*)
_Z8printnum1A  <---> void printnum(A)
_Z8printnum2AA <---> void printnum(AB)
_Z8printnumii  <---> void printnum(int, int)
_Z8printnumic  <---> void printnum(int, char)
_Z8printnumiii <---> char printnum(int, int, int)

规律就是基本数据类型取一个首字母，按照参数列表顺序拼接就行了，自定义的类型就取类型名字，前面加一个类型名字字符数。指针就类型前面加一个P,具体规则可以网上搜一搜。

可以看到一个又意思的现象，函数的返回值不被考虑在特征标里面，为什么？

一些注意点

一些看起来构成重构的例子，实际不构成：

void foo()
char foo(){}

返回值不同，参数列表相同的情况，为什么？其实举一个反例就知道了。假定返回值构成重载条件，那么有如下函数定义和调用：

int main(void)
{
  foo();
}

因为C/C++语法并未规定函数返回值必须要使用，因此即便函数有返回值，我也可以不用它，上面这个例子编译器就迷糊了，到底是调用void foo(),还是char foo()？
再看一下下面的列子：

void bar(int){}
void bar(const int){}   //提示重复定义，不构成重载
 
int main()
{
    int a = 1;
    bar(a);
}

以上面调用的例子来看，int a = 1;即可以传递给第一个bar也可以传递给第二个bar,因为于将非const值赋给const变量是合法的，但反之则是非法的。

那是不是通过const修饰的就不构成重载呢？并不是，看下面一个例子：

void tar(int *){}
void tar(const int *){}
 
int main()
{
    int a = 1;
    tar(&a);
}

上面那个例子是传值，这里是传指针，仅仅这个区别，为什么这里会构成重载？按照上一个例子

-----------------------------以下内容待完善------------------------
此时你知道我想调用的是传值还是传引用？从语法上来说，都可以，所以产生了歧义，因此这种情况不构成重载。类似的，tar的调用也会产生歧义。

因此记住一个规则，特征标不同，特征标指：参数类型，参数个数，参数顺序。只和参数有关。

比较晦涩的重载

class A
{
public:
    void foo()
    {
        std::cout << "non const foo" << std::endl;
    }
 
    void foo() const
    {
        std::cout << "const foo" << std::endl;
    }
};

嗯，就问你吊不吊，这2个货构成重载。说好的特征标呢？？？？