【C++引用+函数】探秘 C++ 技术黑匣子：引用与函数的高效之道

每文一诗 💪🏼

近水楼台先得月，向阳花木易为春 ——宋/苏麟《断句》

译文：靠近水边的楼台（因为没有树木的遮挡），能先看到月亮的投影；而迎着阳光的花木，（光照自然好得多，所以发芽就早），最容易形成春天的景象。

🔥🔥个人主页 🔥🔥

引用的概念

引用是给某一变量起别名，即他是某一个变量的另一个变量，使用引用和使用原变量名是一样的，因为他们共享同一块内存空间

引用的语法

数据类型 &别名 = 变量名

例如

int a = 10;
int &b = a;

#include<iostream>
int main(int argc, char const *argv[])
{  
    int a = 100;
    int &b =a;
    // std::string &b = a;//错误,别名必须和原变量名保持相同的数据类型。
    // int &c;//错误,引用必须赋初始值
    std::cout<<a<<std::endl;
    std::cout<<b<<std::endl;
    return 0;
}

🧐注意：

“&”运算符不是取地址，而是表示对一个变量的引用。
别名必须和原变量名保持相同的数据类型。
引用必须初始化，不初始化会报错。
已经初始化的引用不可修改。

引用的应用

作函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参（指针通过地址传递改变实参）

#include<iostream>

//引用传递
void func1(int &a,int &b)
{
    a = 50;
    b = 80;
    std::cout<<"函数中"<<a<<" "<<b<<std::endl;
}

int main(int argc, char const *argv[])
{
  
    int m = 100;
    int n = 40;
    std::cout<<"改变前"<<m<<" "<<n<<std::endl;
    func1(m,n);
    std::cout<<"改变后"<<m<<" "<<n<<std::endl;
    return 0;
}

输出

作函数返回值

格式：

数据类型& 函数

#include<iostream>
int h = 32;//全局变量
int& func1()
{
    h+=2;
    return h;
}

int main(int argc, char const *argv[])
{
    int& temp = func1();
    std::cout<<"temp: "<<temp<<std::endl;
    temp = 23;
    std::cout<<"h: "<<h<<std::endl;
    return 0;
}

输出：

🧐函数解析：

h为全局变量
函数func1返回了变量h的引用，h=h+2
main函数中用一个引用temp变量来接收函数func1的返回值(此时全局变量h已经有了一个别名)
此时再访问temp变量就相当于访问全局变量h。
由于temp变量就是全局变量h，所以对temp赋值就相当于对全局变量赋值。

不能返回局部变量的引用

#include<iostream>
int& func1()
{
    int h=2;
    h+=2;
    return h;
}

int main(int argc, char const *argv[])
{
    int& temp = func1();
    std::cout<<"temp: "<<temp<<std::endl;
    return 0;
}

编译报错（局部变量被返回）

输出：

🧐解释：

因为函数内定义的变量是局部变量，局部变量的引用不能被返回，因为局部变量的生命周期和函数一样，当函数执行完之后，这个局部变量的内存会被系统回收，此时如果使用该返回值的话，程序会崩溃。具体原因可以在下文引用的本质中理解。

函数调用作为左值

如果函数做左值，那么必须返回引用

#include<iostream>
//引用传递
int& func1(int &a,int &b)
{
    a = 50;
    b = 80;
    std::cout<<"函数中a,b "<<a<<" "<<b<<std::endl;
    return b;
}

int main(int argc, char const *argv[])
{
    int m = 100;
    int n = 40;
    std::cout<<"改变前m,n "<<m<<" "<<n<<std::endl;

    int& temp = func1(m,n);

    std::cout<<"改变后m,n "<<m<<" "<<n<<std::endl;
    
    std::cout<<"返回值temp "<<temp<<" "<<std::endl;

    temp = 30;

    std::cout<<"n的值 "<<n<<" "<<std::endl;

    func1(m,n) = 199;

    std::cout<<"n的值 "<<n<<" "<<std::endl;
    return 0;
}

输出：

🧐函数解析：

首先定义了局部变量m和n
然后定义了一个参数和返回值都为引用的函数func1

对于函数func1，参数是int &a,int &b，意为可以通过修改这个参数（形参的值）来间接修改实参的值，在函数中修改了实参的值，并返回了是形参b的引用。

int& temp = func1(m,n)

在函数func1执行完成后，在函数内部已经修改了实参的值，所以m，n应为修改后的值，temp是函数返回的引用b，即在调用函数是传的第二个参数。

因为temp是函数返回的引用b，即b的别名，而b又是调用函数是传的第二个参数的别名n

所以对temp修改就是对n修改。所以n的值为30。

func1(m,n) = 199

函数作为左值的并不常见，但作为左值出现必须要返回引用。这段代码的本质意思是将199赋值给n。因为func1返回的是形参b的引用，199其实是赋值给了b，而b又是调用函数是传的第二个参数的别名n，所以本质意思是将199赋值给n。所以n的值为199.

😈疑问

        有的人可能会问，不是说不能返回局部变量的引用吗，那在函数func1中，明显是在返回局部变量的引用阿？问的好。

别着急，听我慢慢道来。

        在函数func1中，函数的参数a，b确实是局部变量，但是，你可别忘了，这个参数是引用，而引用是别名，别名的话，就是他还代表别的变量，这里代表的是m，n，而m，n是在函数main中定义的，还是局部变量啊！确实，但是程序也没报错。其实这里在main函数中的m，n的生命周期和main函数一样，而main函数的生命周期和程序的生命周期通常也是一样的，

        所以虽然在func1函数返回b时，func1函数执行完成了，局部变量b应该被回收，但b代表main函数中的n，func1函数执行完成了，但main函数还未完成，即n的生命周期还未完成，当main函数执行完后，程序就执行完了，此时所有的资源已经被释放。

        所以没毛病！

引用本质

引用的本质是一个指针常量

即int& a = b;转化为 int* const a = &b;

即指针的指向不能修改，但指针指向的值可以改变。

#include<iostream>
//发现是引用，转换为 int* const ref = &a;
void func(int& ref){
    ref = 100; // ref是引用，转换为*ref = 100
}
int main(){
    int a = 10;
    //自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
    int& ref = a;
    ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
    std::cout << "a:" << a << std::endl;
    std::cout << "ref:" << ref << std::endl;
    func(a);
    return 0;
}

输出

常量引用

格式：

const 数据类型& 变量

#include<iostream>
void func1(const int &a,const int &b)
{
    // a = 50;
    // b = 80;错误,不能通过形参修改实参
    std::cout<<"函数中a,b "<<a<<" "<<b<<std::endl;

}

int main(int argc, char const *argv[])
{
    int m = 100;
    int n = 40;
    func1(m,n);

    // int& ref = 10;错误，引用本身是一个指针常量，所以必须给其赋一个地址
    const int& ref = 10;//加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp;

    // ref = 100;错误，常量引用不能修改
    

    return 0;
}

🍎函数解析：

在引用前面加入const后就不能修改其值。
在函数的参数中使用常量引用，可以防止在函数中通过形参修改实参的误操作
int& ref = 10

这种写法错误，因为引用本身是一个指针常量，所以必须给其赋一个地址，但是const int& ref = 10;这样写就对了。加入const，编译器优化代码，int temp = 10; const int& ref = temp;

函数

函数默认参数

函数在被定义时，可以有默认的参数，即可以给函数的参数赋一个初始值。

作用：可以在调用函数的时候，无需把所有的参数都写上，有默认参数的参数可以不传。

例如

#include<iostream>
int func1(int a ,int b = 5)
{
    return a+b;
}

int main(int argc, char const *argv[])
{
    int m = 100;
    int n = 40;
    int res1 = func1(m);
    std::cout<<"返回值1："<<res<<std::endl;

    int res2 = func1(m,n);
    std::cout<<"返回值2："<<res2<<std::endl;
    return 0;
}

输出：

🍎函数解析：

上述以两种方式调用了函数func1。

func1(m)

函数func1本来有两个参数，但是第二个参数b有初始值5，所以可以在调用函数时只传入一个参数，这个参数默认时函数声明的第一个参数。

func1(m,n)

这个调用方法就比较常见了，所以不用啰嗦。

🔥注意：

如果函数的第一个参数有默认值，那后面的所有参数也必须有默认值
int func1(int a = 5,int b )
{
    return a+b;
}
这个就是错误的，因为如果b补给默认值的话，我们在使用func(m)调用他的时候，这个m会默认只给第一个参数，但是第二个参数是多少呢，显然是不对的。

函数重载

函数重载允许使用相同的函数名处理不同类型或数量的参数，从而提高代码的可读性和可维护性

#include <iostream>

int add(int a, int b) {
    std::cout<<"int add(int a, int b)"<<std::endl;
    return a + b;
}

double add(double a, double b) {
    std::cout<<"double add(double a, double b) "<<std::endl;
    return a + b;
}

double add(int a, double b) {
    std::cout<<"double add(int a, double b) "<<std::endl;
    return a + b;
}

double add(double a, int b) {
    std::cout<<"double add(int a, double b) "<<std::endl;
    return a + b;
}

int add(int a, int b, int c) {
    std::cout<<"int add(int a, int b, int c) "<<std::endl;
    return a + b + c;
}

int main() {
    std::cout << add(1, 2) << std::endl;
    std::cout << add(1.5, 2.4) << std::endl;
    std::cout << add(1, 2.4) << std::endl;
    std::cout << add(1.4, 2) << std::endl;
    std::cout << add(1, 2, 3) << std::endl;
    return 0;
}

输出

🔥代码解析：

int add(int a, int b)：函数参数和返回值类型不同，但函数名称相同

double add(double a, double b):函数参数和返回值类型不同，但函数名称相同

double add(double a, int b):函数参数的顺序不同，但函数名称相同。

int add(int a, int b, int c):函数的参数的数量不同，但函数名称相同。

在函数被调用时，会根据参数的不同来匹配正确的函数，从而实现了一个函数名来做到不同的用法。

🔥🔥个人主页 🔥🔥