C++ day10 (一) 内联函数，引用变量

蔚落 2023-07-11 15:12 2阅读 0赞

### 文章目录 ###

*  内联函数 inline function（宏的进化版）
 *   *  设计目的：提高程序运行速度
     *  内联函数和常规函数的主要区别：编译器把他们组合到程序的机器代码的方式
     *   *  先说说函数调用的具体实现，在内存中都发生了什么，进而引申到内联函数的由来
         *  内联函数的本质（用空间换时间）
         *   *  从中文名和英文名两方面解释内联函数
         *  示例1 内联函数相比于宏的优势（有惊喜！）
 *  引用变量 （C++新增的复合类型，是已定义变量的别名）
 *   *  主要用途：作为函数的形参，可使函数使用原始数据而非副本
     *  创建引用变量 （&不是地址运算符，而是类型标识符的一部分）
     *   *  示例1 引用变量和原变量有相同的值和地址
     *  引用变量本质上是 一个const指针指向的变量
     *   *  示例2 必须在声明时初始化引用，赋值无法修改引用
     *  正题： 按引用传递参数
     *   *  示例3 经典对比：交换函数（三个方式一台戏）
         *  示例4 对于基本类型，使用按值传递更不易出错（传递引用的陷阱）
         *   *  使用常量引用防止示例3的错误
         *  传递引用的限制更严格，初始化非const引用只能传可修改的左值，不可传右值（传引用也没那么香）
         *   *  可以传表达式啊···书打脸了？还是我的编译器太老
             *  上面能通过是因为用了const引用：C++现在只允许把表达式等右值或不可修改的左值传给const引用
     *  const引用在什么情况下会生成临时匿名变量：当实参和const引用形参不匹配时
     *   *  示例 临时匿名变量
         *  示例 把const变量赋给const引用形参
     *  最终结论：通常应直接把引用形参声明为const
     *  右值引用（C++11,前面说的都是左值引用）
     *   *  示例 sqrt函数竟然也在名称空间std
     *  把引用用于结构
     *   *  示例 把返回类型设置为const引用，以阻止合法却错误的赋值，如accumulate(dup, five) = four;
         *   *  按值传递可以返回函数局部变量，但按引用传递不能返回指向函数的局部变量的引用，而应返回形参引用
     *  把引用用于类的对象（C++通常把对象的引用作为函数参数）
     *   *  示例1 string对象，再次示范返回指向函数的局部变量的引用的后果
         *  示例2 基类的引用形参可以接受派生类对象（继承的特征，e.g. ostream类的引用指向ofstream类对象）
         *  对引用的总结

# 内联函数 inline function（宏的进化版） #

## 设计目的：提高程序运行速度 ##

## 内联函数和常规函数的主要区别：编译器把他们组合到程序的机器代码的方式 ##

### 先说说函数调用的具体实现，在内存中都发生了什么，进而引申到内联函数的由来 ###

**编译的最终产品是可执行程序，是一组机器语言指令**，在运行这个程序时，操作系统大佬把这些指令载入内存中，每一条都会有一个内存地址，于是计算机逐步执行这些指令。

跳转，分支等使得程序跳过一些指令，向前或向后执行；

函数调用会使得程序调到被调函数的地址处，在函数的代码执行结束后返回到原来的地址，具体而言，程序在一个函数内部执行到函数调用指令时：他就  
先把这条调用指令的内存地址存下来，  
然后把当前所在函数的所有参数压栈，即复制到栈（专门为这个函数保留的内存块），  
然后跳到被调函数的代码块的起始地址，执行函数代码，  
执行完被调函数的代码后，如果有返回值就把返回值放到寄存器中，  
然后调回主调函数的调用指令地址，把主调函数的变量都出栈，再继续往后执行。

所以函数调用需要来回跳跃，还需要压栈出栈的，需要内存和时间的开销。这种开销对于那种跳跃时间和执行时间相比差不多或者更多的函数，就太大了。所以C++仿照着C的宏，进一步设计了内联函数。

### 内联函数的本质（用空间换时间） ###

内联函数就是把普通函数那种调用时的在内存中来回跳跃这一痛点kill掉了，编译内联函数时，编译器会把内联函数的机器代码直接提到函数调用语句，这样就根本不需调用跳跃了，直接执行代码就好啦。

#### 从中文名和英文名两方面解释内联函数 ####

所以编译器是把内联函数的代码和程序的其他代码内部连接了，所以叫做内联嘛。  
从英文上说，内联函数的英文名是inline function，之前不知为何翻译为内联，而不是行内函数，毕竟Markdown和LaTeX代码中的inline公式就是指行内公示，短小到只占据一行空间。  
昨晚看到一行代码，突然悟了，原来内联函数一般也是短小到只占一行，所以才得此名，毕竟如果内联函数太长，执行函数代码的时间比处理函数调用机制的时间长，那么节省的时间就只占很小一部分；如果代码执行时间很短，则内联函数就可以节省大部分时间。  
这行代码就是：

inline double square (double x) { return x * x;}

短小简单，设计为inline很省时间，尤其是经常调用这个函数又不在乎空间只在乎时间的条件下

### 示例1 内联函数相比于宏的优势（有惊喜！） ###

宏其实是内联代码的最原始的实现，但是内联代码还是要优秀很多的，因为**宏不能传递参数，只可以文本替换**，所以终究做不好有些事情，比如遇到递增递减运算符。

C中也说过，宏的文本替换机制在定义类函数宏时很不灵活，不小心就要出问题

下面以计算数字平方的函数来比较二者：

先说宏：

#define SQUARE(X) X * X

则

a = SQUARE(5.0);//被替换为 5.0 * 5.0，不出错
    b = SQUARE(4.5 + 7.5);//被替换为4.5 + 7.5 * 4.5 + 7.5，出错
    c = SQUARE(a++);//被替换为a++ * a++,出错

改进：

#define SQUARE(X) ((X) * (X))

上面第二个对了，但是第三个还是错误，毕竟递增两次，结果未知，看编译器先干啥了

再看内联函数：

#include <iostream>
    //使用内联函数的通常做法是直接把定义写在放原型的位置，并省略原型
    inline double square(double x){ return x * x;}
    
    int main()
    { 
        double a = square(5);
        double b = square(4.5 + 7.5);
        double c = 13;
    
        std::cout << "a = " << a << ", b = " << b << std::endl;
        std::cout << "c = " << c;
        std::cout << ", c squared = " << square(c++) << std::endl;
        std::cout << "Now c = " << c << '\n';
        return 0;
    }

a = 25, b = 144
    c = 13, c squared = 169
    Now c = 14

我竟然发现了一个意外的事情！！

下面的代码只是把上面的std::cout << "c = " << c;和std::cout << ", c squared = " << square(c++) << std::endl;合为一句，结果就不一样了！！

这是因为分为两句时，语句的分号是一个顺序点，顺序点前后的代码互不影响，前面的代码一定执行完毕并把副作用执行了才会执行顺序点后面的代码，随意输出c=13

而合为一句，这两句之间就没有顺序点了，编译器选择这句代码完全执行结束才把c的值给c,所以c已经递增了才赋值，于是c就成了14.

看来也不要动不动就图省事，把cout拼接铺天盖地的用，要注意这种情况哦。

#include <iostream>
    //使用内联函数的通常做法是直接把定义写在放原型的位置，并省略原型
    inline double square(double x){ return x * x;}
    
    int main()
    { 
        double a = square(5);
        double b = square(4.5 + 7.5);
        double c = 13;
    
        std::cout << "a = " << a << ", b = " << b << std::endl;
        std::cout << "c = " << c << ", c squared = " << square(c++) << std::endl;
        std::cout << "Now c = " << c << '\n';
        return 0;
    }

a = 25, b = 144
    c = 14, c squared = 169
    Now c = 14

结论：  
用宏定义符号变量即可，最好符号变量也用const定义；  
如果要写函数，还是直接选择内联函数比较安全，宏容易出幺蛾子。

# 引用变量 （C++新增的复合类型，是已定义变量的别名） #

引用是复合类型，因为他要基于基本类型，比如int, double啥的，引用类型比如int &, double &等，分别是指向int的引用，指向double的引用

引用对类的设计至关重要。

引用变量和原变量**有相同的值和内存地址**。

## 主要用途：作为函数的形参，可使函数使用原始数据而非副本 ##

这么说的话，你肯定感觉到了引用和指针有一点点像，毕竟传递指针也是使用原始数据。所以引用也可以为函数处理大型的结构提供一种很方便的路径。

## 创建引用变量 （&不是地址运算符，而是类型标识符的一部分） ##

&本是取地址运算符，但是在创建引用变量时他就不是地址运算符了，而是类型标识符的一部分，就像星号在定义指针变量是也不是解引用运算符而是类型标识符的一部分一样的。  
int \*是指向int类型的指针，是一种类型  
int &是指向int的引用，也是一种类型

### 示例1 引用变量和原变量有相同的值和地址 ###

#include <iostream>
    int main()
    { 
        int rats = 5;
        //rodents的类型是int &
        int & rodents = rats;//rodents是一个指向int的引用，现在指向rats变量
    
        std::cout << "rats = " << rats << std::endl;
        std::cout << "rodents = " << rodents << std::endl;
        rats++;//把一个有两个名字的变量递增，和rodents++效果一样
        std::cout << "rats = " << rats << std::endl;
        std::cout << "rodents = " << rodents << std::endl;
    
        std::cout << "&rats = " << &rats << std::endl;
        std::cout << "&rodents = " << &rodents << std::endl;
        return 0;
    }

可以看出，不管操作rats还是rodents,都可以操作这个变量对应的数据对象，他俩是可以完全互换的。

rats = 5
    rodents = 5
    rats = 6
    rodents = 6
    &rats = 0x6dfee8
    &rodents = 0x6dfee8

## 引用变量本质上是 一个const指针指向的变量 ##

先说一下引用的一个使用要点：必须在声明的同时初始化！！！

不能像指针那样，先声明，后赋值。

这其实就是因为引用的本质，在利用const指针，const指针就必须声明的同时初始化，因为你不当时初始化，过后由于是const，人家就不让你改了，不准指向别人了。

//直接定义引用
    int & rodents = rats;
    //本质是拐着弯的利用指针
    int * const pr = &rats;//pr是const指针，指向rats,*pr就是rodents

所以你直接定义引用变量rodents，就相当于先定义了一个const指针变量pr,让pr指向你想引用的变量（pr将永远指向这个变量，因为指针是const常量，不可修改），然后把pr解引用就得到了你想引用的那个变量。这个过程中没有副本，全是原身。

以后你用rodents实际上都是在用\*pr，只不过C++为了方便广大猿们，专门定义了引用类型，但是底层的实现细节实际上还是在用const指针，不过是实现被抽象隐藏了罢了。

### 示例2 必须在声明时初始化引用，赋值无法修改引用 ###

#include <iostream>
    int main()
    { 
        int rats = 5;
        int & rodents = rats;//rodents是一个指向int的引用，现在指向rats变量
    
        std::cout << "rats = " << rats << std::endl;
        std::cout << "rodents = " << rodents << std::endl;
        std::cout << std::endl;
    
    
        int bunnies = 50;
        rodents = bunnies;
        std::cout << "rats = " << rats << std::endl;
        std::cout << "rodents = " << rodents << std::endl;
        std::cout << "bunnies = " << bunnies << std::endl;
        std::cout << "&rats = " << &rats << std::endl;
        std::cout << "&rodents = " << &rodents << std::endl;
        std::cout << "&bunnies = " << &bunnies << std::endl;
        return 0;
    }

可以看到， rodents = bunnies;这句代码并不能使得rodents成为指向bunnies的引用，只是等效于rats =bunnies;做了一个赋值而已。

说过了，引用的本质是const指针，一辈子只会效忠于初始化的那个变量，极为专情，想扭曲使其指向别的变量绝无可能。

rats = 5
    rodents = 5
    
    rats = 50
    rodents = 50
    bunnies = 50
    &rats = 0x6dfee8
    &rodents = 0x6dfee8
    &bunnies = 0x6dfee4

## 正题： 按引用传递参数 ##

前面的两个小示例只是为了说明引用的特点和本质，现在开始说引用的主战场：函数形参。这才是引用的经典用法。

此图对两种传参方式分析透彻，说明清晰，值得观摩。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]

### 示例3 经典对比：交换函数（三个方式一台戏） ###

交换算法都用的三变量经典法

通过这个示例也能看到引用和指针的一些区别，函数原型上，内部使用上，比如指针法还要用解引用运算符和地址符来辅助，引用却是形如普通变量一般，直接裸奔

#include <iostream>
    void swapv(int a, int b);//按值传递
    void swapp(int *a, int * b);//按指针传递
    void swapr(int & a, int &b);//按引用传递
    
    int main()
    { 
        int wallet1 = 100, wallet2 = 200;
    
        std::cout << "wallet1: $" << wallet1 << ", wallet2 = $" << wallet2 << std::endl;
        swapv(wallet1, wallet2);
        std::cout << "wallet1: $" << wallet1 << ", wallet2 = $" << wallet2 << std::endl;
        swapp(&wallet1, &wallet2);
        std::cout << "wallet1: $" << wallet1 << ", wallet2 = $" << wallet2 << std::endl;
        swapr(wallet1, wallet2);
        std::cout << "wallet1: $" << wallet1 << ", wallet2 = $" << wallet2 << std::endl;
        return 0;
    }
    
    void swapv(int a, int b)
    { 
    	//a, b是新变量，是wallet1，wallet2的副本，这里只交换了副本的值
        int temp;
        temp = a;
        a = b;
        b = temp;
    }
    
    void swapp(int *a, int *b)
    { 
    	//a, b是新变量，但指向wallet1,wallet2
        int temp;
        temp = *a;
        *a = *b;
        *b = temp;
    }
    
    void swapr(int &a, int &b)
    { 
    	//变量a,b只是wallet1,wallet2的别名，不是新变量
        int temp;
        temp = a;
        a = b;
        b = temp;
    }

按值传递，失败  
按指针传参，成功  
传递引用，成功

注意按引用传参也只需要传变量名，不像指针还要用&  
通过函数调用是看不出来函数是不是按引用传递的，得看函数头或者函数原型。

wallet1: $100, wallet2 = $200
    wallet1: $100, wallet2 = $200
    wallet1: $200, wallet2 = $100
    wallet1: $100, wallet2 = $200

### 示例4 对于基本类型，使用按值传递更不易出错（传递引用的陷阱） ###

当数据为结构和类那种比较大的数据时，引用参数非常有用，后面会说。

但是基本类型，按值传递就够用啦。毕竟C只有按值传递，不也工作地好好的。

//为了展示传递引用可能出现的错误，函数故意编写的很奇怪
    #include <iostream>
    double cube(double x);
    double refcube(double & x);
    
    int main()
    { 
        double a = 3.0;
    
        std::cout << cube(a) << " = cube of " << a << std::endl;
        std::cout << refcube(a) << " = cube of " << a << std::endl;
        return 0;
    }
    
    double cube(double x)
    { 
        x *= x * x;
    
        return x;
    }
    
    double refcube(double & x)
    { 
    	//x是变量a的引用，改变x就是改变a
        x *= x * x;
    
        return x;
    }

没有出错

27 = cube of 3
    27 = cube of 3

但是！！如果把输出拆开，你就会发现a的值变了！！！

这还是因为顺序点的问题，搞不清楚以后干脆直接一次只输出一个变量算了。

std::cout << refcube(a) << " = cube of ";
    std::cout << a << std::endl;

27 = cube of 3
    27 = cube of 27

为了安全，不修改引用指向的变量的值，我们要使用常量引用

#### 使用常量引用防止示例3的错误 ####

把函数定义和函数原型中的引用改为const引用，则上面的那种代码会被编译器发现错误，从而避免掉这个错误

double refcube(const double & x)
    { 
        x *= x * x;
    
        return x;
    }

编译器生成错误消息  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]

### 传递引用的限制更严格，初始化非const引用只能传可修改的左值，不可传右值（传引用也没那么香） ###

如果函数的形参是引用变量，那就要给传来的变量起别名，这要求传来的实参是一个变量，而不是值，所以不能传表达式，因为每个表达式都有一个值，传表达式实际上是传了他的值

按值传递的灵活性更大，不管你括号里什么形式，总之它有一个值就好了，比如表达式，数组名（地址是个值呀），数组元素等等，都行

但是按引用传递只能传递变量，不可以是有计算的表达式，因为表达式是右值，不可修改的常量值，所以数组元素，结构成员可以传

如果是传给const形参，那么不可修改的左值（即const数据），以及不可修改的右值（右值都是不可修改的）都可以传。

#### 可以传表达式啊···书打脸了？还是我的编译器太老 ####

我的实验说明，可以传表达式给引用形参，这样子形参x不再是指向a的引用，而是指向a+1的引用（编译器将会创建一个临时的无名变量，把他初始化为a+1的值，然后让x成为这个临时变量的引用），可以看到x和a的值和地址都不一样

书上说C++早期确实允许我试验中的这种情况，允许表达式给引用，内部原理就是上一段说的临时变量。但是书上还说现在的C++禁止这个行为，我用了C++11和C++14标准编译都是不警告不报错，懵

//为了展示传递引用可能出现的错误，函数故意编写的很奇怪
    #include <iostream>
    double cube(double x);
    double refcube(const double & x);
    
    int main()
    { 
        double a = 3.0;
    
        std::cout << cube(a) << " = cube of " << a << std::endl;
        std::cout << std::endl;
    
        std::cout << refcube(a) << " = cube of ";
        std::cout << a << std::endl;
        std::cout << "In main(), address of a: " << &a << '\n';
        std::cout << std::endl;
    
        std::cout << refcube(a + 1) << " = cube of ";
        std::cout << a + 1 << std::endl;
        std::cout << "In main(), address of a: " << &a << '\n';
        return 0;
    }
    
    double cube(double x)
    { 
        x *= x * x;
    
        return x;
    }
    
    double refcube(const double & x)
    { 
        double y = x * x * x;
        std::cout << "In refcube(), x = " << x << '\n';
        std::cout << "In refcube(), address of x: " << &x << '\n';
        return y;
    }

27 = cube of 3
    
    In refcube(), x = 3
    In refcube(), address of x: 0x6dfee0
    27 = cube of 3
    In main(), address of a: 0x6dfee0
    
    In refcube(), x = 4
    In refcube(), address of x: 0x6dfee8
    64 = cube of 4
    In main(), address of a: 0x6dfee0

#### 上面能通过是因为用了const引用：C++现在只允许把表达式等右值或不可修改的左值传给const引用 ####

我竟然又阴差阳错碰出一个知识点

书真是，讲话不一次讲完整，大喘气，我还务必纳闷怎么我不报警不报错呢····

把上面的代码函数原型和定义中的const去掉，编译器立刻报错：

用一个**右值**（rvalue, right value）对非const引用的无效初始化  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]

看来：  
初始化非const引用只能传递可修改的左值，即变量。  
只有初始化const引用才可以传递不可修改的右值，即常量，或者不可修改的左值，即const变量。

## const引用在什么情况下会生成临时匿名变量：当实参和const引用形参不匹配时 ##

刚才碰巧发现了const引用赋表达式，即右值，是正确的，并且说清楚了其中的内在机制：C++自动创建的临时的匿名变量。这些变量在退出函数调用后就被释放了。

那么只有这种情况会生成临时变量吗？

当然不是。

当程序员脑子不好使时，给函数传去的实参和函数的const引用形参的不匹配，C++就只好自己解决这个矛盾：生成临时变量。

那什么是不匹配呢？具体而言有两种不匹配：

*  1.类型。实参和const形参的参数类型不一致，但是又可以转换为正确类型，比如const形参是double，你给个int,这种对结果无甚影响的小错，const形参岂会在意，得饶人处且饶人，就帮你转为double就好了。

比如：把上面程序小小一改

#include <iostream>
    double refcube(const double & x);
    
    int main()
    { 
        int a = 3;
    
        std::cout << refcube(a) << " = cube of ";
        std::cout << a << std::endl;
        std::cout << "In main(), address of a: " << &a << '\n';
        std::cout << std::endl;
    
        std::cout << refcube(a + 1) << " = cube of ";
        std::cout << a + 1 << std::endl;
        std::cout << "In main(), address of a: " << &a << '\n';
        return 0;
    }
    
    
    double refcube(const double & x)
    { 
        double y = x * x * x;
        std::cout << "In refcube(), x = " << x << '\n';
        std::cout << "In refcube(), address of x: " << &x << '\n';
        return y;
    }

还是那个美丽的正确结果

In refcube(), x = 3
    In refcube(), address of x: 0x6dfee0
    27 = cube of 3
    In main(), address of a: 0x6dfedc
    
    In refcube(), x = 4
    In refcube(), address of x: 0x6dfee8
    64 = cube of 4
    In main(), address of a: 0x6dfedc

再举一个类型不匹配的例子，但是这个代码不能通过编译，因为现在C++代码已经不允许类型不匹配还传给非const引用了。

#include <iostream>
    void swapr(int & a, int &b);//按引用传递
    
    int main()
    { 
        long wallet1 = 100, wallet2 = 200;
    
        std::cout << "wallet1: $" << wallet1 << ", wallet2 = $" << wallet2 << std::endl;
        swapr(wallet1, wallet2);//编译出错
        std::cout << "wallet1: $" << wallet1 << ", wallet2 = $" << wallet2 << std::endl;
        return 0;
    }
    
    void swapr(int &a, int &b)
    { 
    	//变量a,b只是wallet1,wallet2的别名，不是新变量
        int temp;
        temp = a;
        a = b;
        b = temp;
    }

如果早期， C++还允许上述代码通过，即类型不匹配仍可以传给非const引用时呢,会成功交换两个数吗？

答案是：不能。因为早期虽然允许，但是这种情况还是会创建临时变量，函数里**只是交换了临时变量的值**，根本没有交换程序员希望交换的变量。

*  2.实参不是左值，但是类型匹配。毕竟不能同时犯多种错误，谁会帮你收拾一个大烂摊子。上面以为书打脸的示例就是遇到了这种情况，传来的是个表达式，右值。

### 示例 临时匿名变量 ###

#include <iostream>
    double refcube(const double & x);
    
    int main()
    { 
        double side = 3.0;
        double *pd = &side;
        double &rd = side;
        long edge = 5L;
        double lens[4] = { 2.0, 5.0, 10.0, 12.0};
        
        double c1 = refcube(side);//x和side等价
        double c2 = refcube(*pd);//x和*pd，side等价
        double c3 = refcube(rd);// rd和x,side等价
        double c4 = refcube(lens[3]);//x和lens[2]等价
        double c5 = refcube(edge);//x是临时匿名变量
        double c6 = refcube(2.0);//x是临时匿名变量
        double c7 = refcube(side + 20.0);//x是临时匿名变量
        
        return 0;
    }
    
    
    double refcube(const double & x)
    { 
        std::cout << "In refcube(), x = " << x << '\n';
        std::cout << "In refcube(), address of x: " << &x << '\n';
        return x * x * x;
    }

### 示例 把const变量赋给const引用形参 ###

由于变量本身就是const保护的，所以函数肯定是不可以改变它的值的，如果需要改变它的值，那就无能为力了。

又因为他自己都是const，你传给非const引用形参也传不进去，会报错，所以引用形参也必须是const。

#include <iostream>
    double refcube(const double &a);
    
    int main()
    { 
        const double x = 2.0;
    
        std::cout << "cube of " << x ;
        std::cout << " is " << refcube(x) << std::endl;
        return 0;
    }
    
    double refcube(const double &a)
    { 
    	return a * a * a;
    }

cube of 2 is 8

## 最终结论：通常应直接把引用形参声明为const ##

## 右值引用（C++11,前面说的都是左值引用） ##

前面说了半天引用，其中一个很大的话题就是引用的严格限制，不允许引用变量指向右值，只准指向左值（可修改的不可修改的都行哈）。

右值引用用俩&声明，同样，这里的&和地址符没有关系

### 示例 sqrt函数竟然也在名称空间std ###

没想到sqrt函数竟然也是名称空间std的

#include <iostream>
    #include <cmath>
    int main()
    { 
        double && rref = std::sqrt(36.00);//rref指向一个函数调用表达式的值
        double j = 15.0;
        double && jref = 2.0 * j + 14.5;//jref指向一个运算表达式，即指向常量值
    
        std::cout << rref << '\n';
        std::cout << jref << '\n';
    
        return 0;
    }

6
    44.5

## 把引用用于结构 ##

引入引用这种类型本来初衷就是为了给结构和类这些用户自定义类型用的，而不是用于基本类型。

### 示例 把返回类型设置为const引用，以阻止合法却错误的赋值，如accumulate(dup, five) = four; ###

#include <iostream>
    #include <string>
    struct free_throws
    { 
        std::string name;
        int made;
        int attempts;
        float percent;
    };
    
    void display(const free_throws & ft);
    void set_pc(free_throws & ft);
    free_throws & accumulate(free_throws & target, const free_throws & source);
    void set_pc_p(free_throws * ft);//set_pc函数的指针版本
    
    int main()
    { 
        //初始化多个结构对象
        //若指定的初始值比成员少，则余下成员初始化为0
        free_throws one = { "Ifelsa Branch", 13, 14};
        free_throws two = { "Andor Knott", 10, 16};
        free_throws three = { "Minnie Max", 7, 9};
        free_throws four = { "Whily Looper", 5, 9};
        free_throws five = { "Long Long", 6, 14};
        free_throws team = { "Throwgoods", 0, 0};
    
        free_throws dup;
    
        set_pc(one);//这个函数不能按值传递，否则不成功，可以使用指针和引用
        display(one);//此函数可以按值传递，但是相比于复制原始结构，按引用可节省时间和内存
        accumulate(team, one);//要修改第一个结构，所以第一个是引用，第二个是const引用
        display(team);
    
        display(accumulate(team, two));
        accumulate(accumulate(team, three), four);
        display(team);
    
        dup = accumulate(team, five);
        std::cout << "Displaying team:\n";
        display(team);
        std::cout << "Displaying dup after assignment:\n";
        display(dup);
        set_pc(four);
        
        //ill-advised assignment
        accumulate(dup, five) = four;//由于accumulate(dup, five)的返回值是结构体dup的引用
        //所以赋值使得结构体dup被修改
        //糟糕的是，这个程序必须把accumulate函数的返回值和第一个参数设置为非const，所以无法避免这种错误
        std::cout << "Displaying dup after ill-advised assignment:\n";
        display(dup);
    
        return 0;
    }
    
    void display(const free_throws & ft)
    { 
        using std::cout;
        cout << "Name: " << ft.name << '\n';
        cout << "Made: " << ft.made << '\t';
        cout << "Attempt: " << ft.attempts << '\t';
        cout << "Percent: " << ft.percent << '\n';
    }
    
    void set_pc(free_throws & ft)
    { 
        if (ft.attempts != 0)
            ft.percent = 100.0f * float(ft.made) / float(ft.attempts);
        else
            ft.percent = 0;
    }
    
    void set_pc_p(free_throws * ft)
    { 
        //set_pc函数的指针版本，调用:set_pc_p(&one);
        if (ft->attempts != 0)
            ft->percent = 100.0f * float(ft->made) / float(ft->attempts);
        else
            ft->percent = 0;
    }
    
    free_throws & accumulate (free_throws & target, const free_throws & source)
    { 
        //这个函数中target会被改变，所以有无返回值都行，要返回值是为了便于连续使用本函数
        target.attempts += source.attempts;
        target.made += source.made;
        set_pc(target);
    
        return target;//返回的是引用
    }

accumulate(dup, five) = four;这条语句虽然看上去就十分别扭，结果也没啥好作用，但是他确实是合法语句。**因为赋值语句只要求左边的表达式是一个可以修改的左值即可，即左边表达式标识一个可修改的内存块**。这里，左边的函数调用返回的引用标识的就是一个可修改的内存快。

Name: Ifelsa Branch
    Made: 13        Attempt: 14     Percent: 92.8571
    Name: Throwgoods
    Made: 13        Attempt: 14     Percent: 92.8571
    Name: Throwgoods
    Made: 23        Attempt: 30     Percent: 76.6667
    Name: Throwgoods
    Made: 35        Attempt: 48     Percent: 72.9167
    Displaying team:
    Name: Throwgoods
    Made: 41        Attempt: 62     Percent: 66.129
    Displaying dup after assignment:
    Name: Throwgoods
    Made: 41        Attempt: 62     Percent: 66.129
    Displaying dup after ill-advised assignment:
    Name: Whily Looper
    Made: 5 Attempt: 9      Percent: 55.5556

怎么避免这种奇怪又毫无作用的赋值呢？

通过把返回类型设置为const引用。这样函数的返回值是一个不可修改的左值，赋值语句就不能通过编译了，于是这种错误得到阻止。但是，随之而来的副作用是嵌套调用accumulate函数也将不合法，要分为两句。

const free_throws & accumulate (free_throws & target, const free_throws & source)
    { 
        //这个函数中target会被改变，所以有无返回值都行，要返回值是为了便于连续使用本函数
        target.attempts += source.attempts;
        target.made += source.made;
        set_pc(target);
    
        std::cout << "target.made = " << target.made;
        std::cout << " address of target: " << &target << '\n';
    
        return target;//返回const引用
    }

//accumulate(accumulate(team, three), four);//报错
    accumulate(team, three);
    accumulate(team, four);

#### 按值传递可以返回函数局部变量，但按引用传递不能返回指向函数的局部变量的引用，而应返回形参引用 ####

这是因为变量作用域

返回引用和返回普通的值略有区别，比如以前按值传递，你可以返回函数中定义的局部变量，甚至我写函数都习惯了一上来就创建一个返回值类型的局部变量，然后直接写return这个变量，最后才写中间计算过程。因为**按值传递，返回值都是右值，右值不可通过地址访问**，使用**复制**机制，即主调函数会把被调函数返回的值的副本取走，所以可以实现。比如：

double m = sqrt(36.0);//编译器会把结果6.0放在一个临时位置，然后回到主调函数，再去那个临时位置把结果复制出来

但是按引用传递可就不行了，因为不是复制机制，你不能让一个指针指向被释放的内存呀，也不能让引用指向一个不再存在的变量，会导致未知结果，所以如果实在要返回引用，最好的避免问题的方式就是：返回作为参数的引用。上面的示例中accumulate函数就是这么做的。

当然啦，同理，你也不能返回一个指向函数局部变量的指针。

但是返回指针或者返回引用相比于返回值（按值传递）的好处是：**当返回的是大型结构和数组时，按值传递的效率不高**，空间时间的开销都大。

比如上面程序中加一个函数

const free_throws & clone2(free_throws & ft)
    { 
        free_throws newguy;
        nuwguy = ft;
        //newguy是局部变量，函数返回后就被释放了，可返回的是指向newguy的引用
        return newguy;   
    }

再在主程序加两句代码，报错：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]

我突然有个疑惑：如果return后面的变量本身不是引用，那么从上面这个报错和警告看到，其实返回的是指向这个非引用变量的引用；那么如果return后面的变量已经是引用了呢，就像上面的accumulate函数返回的是target，target本身已经是引用，但是返回值类型也是引用，那么是否真正**返回的是指向target的引用呢**？还是说编译器看target已经都是引用了，何必再加一层间接，就只**返回target呢**？

在team = accumulate(team, one);里，进入函数后，形参target是指向team的引用，如果返回的是指向target的引用，那么team就变成了指向target的引用。于是team和target成了两个互相指向的引用，你指我我指你，可能吗？

我觉得第一种猜测更正确更合理。

## 把引用用于类的对象（C++通常把对象的引用作为函数参数） ##

类的对象也可能比较大，所以一般C++的实现都是传引用，不传对象本身。

### 示例1 string对象，再次示范返回指向函数的局部变量的引用的后果 ###

string类对象使得字符串拼接好简单啊，直接相加就好了

#include <string>
    #include <iostream>
    using namespace std;
    string version1(const string & s1, const string & s2);//参数是const引用,返回string对象，而不是引用
    const string & version2(string & s1, const string & s2);//第一个引用参数不是const的，说明想修改它以返回它
    const string & version3(string & s1, const string & s2);//和version2同类型
    
    int main()
    { 
        string input, copy, result;//程序想把字符串"***"放在字符串input左右，得到result
    
        cout << "Enter a string:\n";
        getline(cin, input);
        copy = input;//version2会修改input，所以version3要用copy
    
        cout << "Your string as entered: " << input << endl;
        result = version1(input, "111");//细心的人会发现，实际上"111"是C风格字符串，并不是string对象，他的类型是const char *
        cout << "Your enhanced string: " << result << endl;
        cout << "Your original string: " << input << endl << endl;
    
        result = version2(input, "222");//和version2(input, "222");result = input;两句代码等效
        cout << "Your enhanced string: " << result << endl;
        cout << "Your original string: " << input << endl << endl;
    
        input = copy;
        result = version3(input, "333");
        cout << "Your enhanced string: " << result << endl;
        cout << "Your original string: " << input << endl;
        return 0;
    }
    
    string version1(const string & s1, const string & s2)
    { 
        //返回的是对象本身，而非引用
        string temp;//一个新的string对象，是这个函数私有的，函数执行完毕就不存在了
    
        temp = s2 + s1 + s2;
    
        return temp;
    }
    const string & version2(string & s1, const string & s2)
    { 
        s1 = s2 + s1 + s2;
    
        return s1;
    
    }
    const string & version3(string & s1, const string & s2)
    { 
    	//代码和version1一样，但是返回类型是引用，所以错误
        string temp;
    
        temp = s2 + s1 + s2;
    
        return temp;
    }

虽然通过编译，但是编译器关于返回指向函数局部变量的引用的错误给了警告，在version3函数中，程序崩溃了。  
![在这里插入图片描述][2020030821461788.png]

Enter a string:
    It's not my fault. Your string as entered: It's not my fault.
    Your enhanced string: 111It's not my fault.111 Your original string: It's not my fault.
    
    Your enhanced string: 222It's not my fault.222 Your original string: 222It's not my fault.222
    
    
    Process returned -1073741819 (0xC0000005)   execution time : 17.344 s

其中version1把参数改为非引用也可以，如下，成了传统的按值传递，不如传引用的效率高。因为函数需要创建一个两个新的string对象s1, s2，并把input和"111"两个string对象的数据复制到s1, s2中。

string version1(const string s1, const string s2)
    { 
        //返回的是对象本身，而非引用
        string temp;
    
        temp = s2 + s1 + s2;
    
        return temp;
    }

Enter a string:
    aaa
    Your string as entered: aaa
    Your enhanced string: 111aaa111
    Your original string: aaa

在调用version1时，result = version1(input, “111”);，实参的类型分别是string和const char \*，形参类型都是const string &，第一个没的说，第二个要说一下，分两点说明：

*  可以用C风格字符串初始化string对象。因为string类定义了char \* 到string的转变。
 *  前面说了，形参为const引用时，程序如果发现实参和形参类型不同，但是实参类型可以转换为形参类型时，编译器就会创建一个形参类型的临时变量并用实参初始化，然后传递一个指向这个临时变量的const引用。

所以result = version1(input, “111”);使用的是临时变量哦，同时也利用了const char \*到string对象的转换

### 示例2 基类的引用形参可以接受派生类对象（继承的特征，e.g. ostream类的引用指向ofstream类对象） ###

基类的引用可以指向派生类的对象，且不需要强制类型转换。

前面说过，派生类对象可以使用基类的特性，比如使用基类的方法。这实际上是继承，继承是一种语言特性，它使得一个类的特性可以传递给另一个类。

这个示例以输出流，输出文件流两个类作为例子

从小就没学清楚放大镜倍数，只是临考背一下，现在趁机再了解一下，原来放大镜的放大倍数是物镜的焦距除以目镜的焦距。所以物镜的焦距越大，目镜的焦距越小，放大倍数就越大。

#include <iostream>
    #include <fstream>
    #include <cstdlib>
    using namespace std;
    void file_it(ostream & os, double fo, const double fe[], int n);
    const int LIMIT = 5;
    
    int main()
    { 
        ofstream fout;
        const char * filename = "ep_data.txt";
        fout.open(filename);
        if (!fout.is_open())//is_open函数没有参数！！
        { 
            cout << "Can't open " << filename << ". Bye!\n";
            exit(EXIT_FAILURE);
        }
        double objective;//物镜的焦距
        cout << "Enter the focal length of your telescope objective in mm: ";
        cin >> objective;
        double eps[LIMIT];
        cout << "Enter the focal lengths, in mm, of " << LIMIT << " eyepieces:\n";
        for (int i = 0; i < LIMIT; ++i)
        { 
            cout << "Eyepiece #" << i + 1 << ": ";
            cin >> eps[i];
        }
        file_it(fout, objective, eps, LIMIT);//参数os(类型：ostream &)指向ofstream对象fout
        file_it(cout, objective, eps, LIMIT);//参数os(类型：ostream &)指向ostream对象cout
    
    
        return 0;
    }
    
    void file_it(ostream & os, double fo, const double fe[], int n)
    { 
    	//setf方法是ostream类的格式化方法，用于设置各种格式化状态
        ios_base::fmtflags initial;//ios_base::fmtflags是一个数据类型，用于存储调用setf方法之前的格式化设置
        initial = os.setf(ios_base::fixed);//把对象os置于定点表示法模式
        os.precision(0);//对象处于定点模式下时，显示多少位小数点
        os << "Focal length of objective: " << fo << "mm\n";
        os.setf(ios::showpoint);//把对象os置于显示小数点的模式
        os.precision(1);
        os.width(12);//设置下次输出使用的字段宽度，下一个值显示完成则恢复默认设置：即零字段宽度，即刚好容纳要显示的内容
        os << "f.l. eyepiece";
        os.width(15);
        os << "magnification" << endl;
        for (int i = 0; i < n; ++i)
        { 
            os.width(12);
            os << fe[i];
            os.width(15);
            os << int (fo / fe[i] + .5) << endl;
        }
        os.setf(initial);//把所有的格式化设置恢复到原来的值，这使得对象os回到传递给file_it函数之前的状态
    }

每个对象都存储了自己的格式化设置，fout传给file\_it，被setf方法修改了格式，但是最后得到了恢复。cout也一样。

setf方法后面还会专门讲，现在会用即可。

Enter the focal length of your telescope objective in mm: 1800
    Enter the focal lengths, in mm, of 5 eyepieces:
    Eyepiece #1: 30
    Eyepiece #2: 20
    Eyepiece #3: 14
    Eyepiece #4: 7.5
    Eyepiece #5: 8.8
    Focal length of objective: 1800mm
    f.l. eyepiece  magnification
            30.0             60
            20.0             90
            14.0            129
             7.5            240
             8.8            205

![在这里插入图片描述][20200308233713393.png]

### 对引用的总结 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 4]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200306152028750.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200306162748450.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200306170109656.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200307114510869.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[2020030821461788.png]: https://img-blog.csdnimg.cn/2020030821461788.png
[20200308233713393.png]: https://img-blog.csdnimg.cn/20200308233713393.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200309084853199.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70