【C-＞Cpp】由C迈向Cpp（3）-CSDN博客

为什么C语言不支持函数重载？

我们知道，编译器在对源文件进行编译后，会进行链接。在链接过程中，编译器会在符号表中查找源文件中存在的函数，并将函数的头文件.h（声明）和源文件.c（定义）进行链接，链接过程中需要根据头文件中函数的特征来在符号表（在源文件.c编译过程中产生的函数名对照表）中查找查找。

C语言不支持函数重载的原因就是C语言是直接通过函数名来查找函数的定义的，一旦有重名，编译器就会报错。而Cpp是通过修饰后的函数名来查找函数的定义的，即使有重名的函数，只要满足重载的要求，也可以成功编译运行。

名称修饰的过程是由编译器自动完成的，它将根据函数的参数类型、参数个数和参数顺序等信息生成一个唯一的符号名。这样，在目标文件中就能够通过不同的符号名来区分不同的重载函数。

（下面一linux的g++为例）

linux下的g++函数在修饰后变成：{ _Z + 函数名长度 + 函数名 + 类型首字母 }
//实例如下
Add(int,int)       ->   call     _Z3Addii
Add(double,double) ->   call     _Z3Adddd
//只要类型不同，类型顺序不同，类型个数不同，都可以让修饰后函数名不同，
//编译器可以区分不同的函数名，这样就构成了重载
编译同一个文件，对于文件中的同一个函数，用gcc和g++编译出来的函数名称是不同的（符合上面规则）：

用gcc编译的函数func1函数：

用g++编译的函数func1函数：

函数重载的作用主要有以下几点：

提高代码的复用性：通过函数重载，可以在一个类中定义多个功能相似的函数，避免了重复编写代码的问题。
提高程序的可读性：使用函数重载可以让程序更加直观清晰，减少了函数命名的复杂性。
增强了函数的灵活性：通过函数重载可以根据不同的参数选择不同的实现方式，从而提供了更多的选择。

需要注意以下几点：

重载函数的返回类型不可以作为重载的条件，只有参数列表不同才能作为重载的条件。
重载函数的参数列表必须不同，参数个数不同或者参数类型不同都可以作为重载的条件。
重载函数可以有不同的访问修饰符，比如一个是私有的，一个是公有的。

需要注意的是，C++规定了可以函数重载，但是具体实现的名称修饰规则是由编译器决定的，不同的编译器可能会有不同的修饰规则。

（二）引用

（1）引用

引用不是新定义一个变量，而是给已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共同用一块内存空间。

（2）语法

i ，别名：

引用提供了一个变量的别名，可以通过引用来访问已经存在的变量。这使得代码更加清晰和易读，同时也让函数传参更加方便，避免了拷贝大量数据的开销。

基本使用：
int i = 0;
int& j = i;//给i取别名j，j是i的别名
j与i共用同一块内存地址；

对i与对j的运算是等同的，j++后 i = 1 （其实就是i++ 后 i = 1）；

（引用类型必须和引用实体是同种类型的）

引用的特性：

引用在定义时必须初始化；

一个变量可以有多个引用；

可以对别名取别名（套娃），对别名取别名，其实就是对原变量取别名，原变量与他的别名的地位是等同的（一个空间的名字可以是 “ i ”也可以是 “ j ” ）；

引用一旦引用一个实体，不能再引用其他实体；

引用需要与创建变量区分：
int i = 0; 
int j = i;//创建一个变量j初始化为0

ii，传参：

引用作为函数参数，可以将参数按引用传递，而不是按值传递。这样可以避免参数的拷贝，提高函数的执行效率，并且可以在函数内部修改参数的值（也就相当于传址），使得函数能够对传入的参数进行修改（同时也更好理解）。
//形参直接用实参的别名接收，便于直接对实参操作
void swap(int& r1,int& r2)
{
    int tem = r1;
    r1 = r2;
    r2 = tem;
}
int main()
{
    int a = 1,b = 2;
    swap(a,b);//不用再传地址，更好理解

    return 0;
}

iii，返回值：

函数可以返回引用类型，这样可以避免拷贝对象的开销，同时也方便链式调用和对象的赋值操作。通过返回引用，函数可以返回一个指向已存在的对象的引用，而不需要创建新的对象。

对于n，是局部变量，存储在栈区，出count函数就会被销毁；

编译器会先将n的值存储在寄存器中，当count函数栈帧销毁后，将寄存器的值赋给ret；(对于内置类型变量，确实是这样，但是对于自定义类型，拷贝需要调用拷贝构造，为了方便解释，按照内置类型）
int count()
{
    int n = 0;
    n++;
    return n;
}

int main()
{

    int ret = count();
    
    return 0;
}
         对于变量n，是静态变量，存储在静态区，不会随着count函数的销毁而销毁；

        编译器仍然会先将n的值存储在寄存器中，当count函数栈帧销毁后，将寄存器的值赋给ret；
int count()
{
    static int n = 0;
    n++;
    return n;
}

int main()
{

    int ret = count();
    
    return 0;
}
为什么两种都需要寄存器的帮助？

如果是返回引用，还需要寄存器的帮助吗？
int& count1()
{
    int n = 0;
    n++;
    return n;
}

int& count2()
{
    static int n = 0;
    n++;
    return n;
}

int main()
{

    int ret1 = count1();
    int ret2 = count2();
    return 0;
}
显然不需要，这样就减少了拷贝；

引用做返回值总结：

第一种返回，直接返回变量的值，称为传值返回；传值返回需要一定的拷贝消耗；

第二种返回，返回的是变量的引用（别名），称为传引用返回；传引用返回避免了拷贝消耗。

（需要拷贝的数据类型不同，拷贝消耗不同。

内置类型拷贝消耗较小，通常寄存器就可以充当新变量来辅助拷贝；

自定义类型拷贝消耗较大，需要调用拷贝构造函数进行拷贝，为了避免这样的消耗，可以使用传引用返回）

只要返回的变量不会随着函数栈帧的销毁而销毁，就可以使用拷贝构造。

引用作返回值，同时也可以做可修改的左值，因为引用本质上就是变量的别名，变量当然可修改；

#define N 50

//静态顺序表
struct AY
{
    int a[N];
    int size;    //大小
    int capacity;//容量
}

//检查是否越界
int& posAt(AY& ay,int i)
{
    assert(i < N)
    return ay.a[i];
}

int main()
{
    AY ay;
    for(int i = 0;i < N;i++)
    {
        posAt(ay,i) = i * 10;//返回引用可作为可被修改的左值
    }
}

iv，修改外部变量：

引用可以作为函数的返回值，在函数内部对外部的变量进行修改。这种方式可以用于实现一些特殊的操作，如对象的赋值操作符重载等。通过引用，可以直接修改外部的变量，而不需要通过指针等方式。

v，避免空指针：

引用在定义时必须初始化，并且不能被修改指向其他对象，这样可以避免了指针的空引用问题。使用引用可以更加安全地操作对象，避免了空指针异常的发生。

（3）指针和引用的区别：

1.引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

完~

未经作者同意禁止转载