从C语言到C++②(第一章_C++入门_中篇)缺省参数+函数重载+引用（中）-阿里云开发者社区

从C语言到C++②(第一章_C++入门_中篇)缺省参数+函数重载+引用（上）：https://developer.aliyun.com/article/1513635

3.引用

3.1引用的概念

引用不是新定义一个变量，而是 给已存在变量取了一个别名，

编译器不会为引用变量开辟内存空间，它和它引用的变量 共用同一块内存空间。

比如你的真实姓名已存在，你的小名或者外号就是一个别名。

语法：数据类型 & 引用名 = 引用实体；

这里的&可不是取地址啊！它是放在数据类型后面的 &，一定要区分开来！

代码演示：

#include <iostream>
using namespace std;
 
int main()
{
    int a = 10;
    int& ra = a;//<====定义引用类型
//（这里取名为 ra，因为引用的英文是 reference，所以后面命名变量时会简写为 r，或者 ref 来代表引用）
    printf("%p\n", &a);
    printf("%p\n", &ra);
 
    cout << a << endl;
    cout << ra << endl;
    return 0;
}

引用在语法层，我们要理解这里没有开新空间，就是对原来的取了一个新名称而已。

再次注意：

① 引用并不是新定义一个变量，只是给一个变量取别名。

② 编译器不会为引用的变量开辟内存空间，它和它引用的变量会共用同一块内存空间。

3.2引用的特性

1. 引用在定义时必须初始化

2. 一个变量可以有多个引用

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

前两个好理解，第三个给出代码演示：

#include <iostream>
using namespace std;
 
int main()
{
  int a = 10;
  int& ra = a;
 
  int b = 20;
  ra = b;       // ?
 
  cout << a << endl;
  cout << ra << endl;
  cout << b << endl;
  cout << ra << endl;
 
  return 0;
}

问号处是什么意思呢？这里是让 ra 变成 b 的别名，还是把 b 的值赋值给 ra 呢？

这里打印了四个20，所以是把 b 的值赋值给 ra 。

引用是不会变的，我们定义它的时候它是谁的别名，就是谁的别名了。

以后就不会改了，它是从一而终的！！！

引用和指针是截然不同的，指针是可以改变指向的：

平常这么写其实没什么意义：

int a = 10;

int& ra = a;

它真正有用的地方在于它能够做参数和做返回值。

3.3引用做参数

我们在C语言教学中讲过 Swap 两数交换的三种方式。

我们当时用的最多的就是利用临时变量去进行交换。

如果把它写成函数形式就是这样：

#include <iostream>
using namespace std;
 
void Swap(int* px, int* py)
{
    int tmp = *px;
    *px = *py;
    *py = tmp;
}
 
int main()
{
    int a = 10;
    int b = 20;
    cout << a << ' ' << b << endl;
    Swap(&a, &b);  // 传址
    cout << a << ' ' << b << endl;
    return 0;
}

这里我们调用 Swap 函数需要传地址，

因为形参是实参的一份临时拷贝，改变形参并不会对实参产生实质性的影响。

但是，我们学了引用之后我们就可以这么玩：

#include <iostream>
using namespace std;
 
void Swap(int& ra, int& rb) 
{
    int tmp = ra;
    ra = rb;
    rb = tmp;
}
int main()
{
    int a = 10;
    int b = 20;
    cout << a << ' ' << b << endl;
    Swap(a, b); // 这里既没有传值，也没有传地址，而是传引用
    cout << a << ' ' << b << endl;
    return 0;
}

是怎么做到交换的？

我们知道，形参是定义在栈帧里面的。

实际调用这个函数的时候，才会给 ra 和 rb 开空间。调用这个函数的时候，把实参传给形参。

那什么时候开始定义的？实参传给形参的时候开始定义的。

ra 是 a 的别名，rb 是 b 的别名，所以 ra 和 rb 的交换，就是 a 和 b 的交换。

因此，我们利用这一特点，就可以轻松实现两数的交换。

我们来梳理一下，顺带复习一下之前讲的函数重载。

在我们一共学了三种传参方式：传值、传地址、传引用。

#include<iostream>
using namespace std;
void Swap(int x, int y) 
{
    int tmp = x;
    x = y;
    y = tmp;
    cout << 1 << endl;
}
 
void Swap(int* px, int* py) 
{
    int tmp = *px;
    *px = *py;
    *py = tmp;
    cout << 2 << endl;
}
 
void Swap(int& rx, int& ry) 
{
    int tmp = rx;
    rx = ry;
    ry = tmp;
    cout << 3 << endl;
}
 
int main()
{
    int a = 10;
    int b = 20;
    Swap(&a, &b);
    //Swap(a, b);  // 报错
    return 0;
}

这里 Swap(a，b) 为什么会报错呢？

这三个 Swap 是可以构成函数重载的，

只要不影响它的函数名修饰规则，就不会构影响！

换言之，修饰出来的函数名不一样，就支持重载！

但是 Swap(a，b) 调用时存在歧义。调用不明确！

编译器不知道调用哪一个，是传值还是传引用，所以会报错。

当时再讲数据结构单链表的时候用的是二级指针，当时没有采用头结点的方式。

那么要传指针的地址，自然要用二级指针的方式接收。

现在我们学了引用，我们就可以试着用引用的方法来解决了（这里我们把 .c 改为 .cpp）

任何类型都是可以取别名的，指针也不例外：

int a = 10;
int& ra = a;
 
int* pa = &a;
int*& rpa = pa

我们来看如何用引用的方法来实现！

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
typedef int SLNodeDataType;
 
typedef struct SingleListNode 
{
    SLNodeDataType data;           // 用来存放节点的数据
    struct SingleListNode* next;   // 指向后继节点的指针
} SLNode;                          
 
void SListPrint(SLNode* pHead);
void SListPushBack(SLNode*& rpHead, SLNodeDataType x);
// ... 略

SList.cpp：

#include "SList.h"
 
/* 打印 */
void SListPrint(SLNode* pHead) 
{
    SLNode* cur = pHead;
    while (cur != NULL) 
{
        printf("%d -> ", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
}
 
/* 创建新节点 */
SLNode* CreateNewNode(SLNodeDataType x) 
{
    //创建，开辟空间
    SLNode* new_node = (SLNode*)malloc(sizeof(SLNode));
    //malloc检查
    if (new_node == NULL) 
    {
        printf("malloc failed!\n");
        exit(-1);
    }
    //放置
    new_node->data = x; //存传入的数据
    new_node->next = NULL; //next默认置空
 
    return new_node; //递交新节点
}
 
/* 尾插（指针的引用） */
void SListPushBack(SLNode*& rpHead, SLNodeDataType x) 
{
    //创建新节点
    SLNode* new_node = CreateNewNode(x);
    //如果链表是空的
    if (rpHead == NULL) 
    {
        //直接插入即可
        rpHead = new_node;
    }
    else 
    {
        //找到尾结点
        SLNode* end = rpHead;
        while (end->next != NULL) 
        {
            end = end->next; //令end指向后继节点
        }
        //插入
        end->next = new_node;
    }
}

解读：这里的 SLNode* & rpHead 就是 pHead 的一个别名。

Test.cpp：

#include "SList.h"
 
// 这里我们不传二级指针了。
//void TestSList1()
//{
//  SLNode* pList = NULL;
//  SListPushBack(&pList, 1);
//  SListPushBack(&pList, 2);
//  SListPushBack(&pList, 3);
//  SListPushBack(&pList, 4);
//
//  SListPrint(pList);
//}
 
// 使用引用的方法：
// 我们传 指针的 引用！
void TestSList2()
{
  SLNode* pList = NULL;
  SListPushBack(pList, 1);
  SListPushBack(pList, 2);
  SListPushBack(pList, 3);
  SListPushBack(pList, 4);
 
  SListPrint(pList);
}
 
 
int main()
{
  TestSList2();
  return 0;
}

3.4 传值返回

这是我们以前的传值返回：

int Add(int a, int b) 
{
    int c = a + b;
    return c;
}
 
int main()
{
    int ret = Add(1, 2);
    cout << ret << endl;
    
    return 0;
}

这里 return 的时候会生成一个临时变量（c 为 3）

将 3 复制给这个临时变量，然后返回给 ret

如果我们直接把 c 交给 ret，就会出现一些问题。

如果直接取 c 给 ret，取到的是 3 还是随机值，就要取决于栈帧是否销毁空间！

这个时候严格来说，其实都是非法访问了。

因为这块空间已经还给操作系统了，这就取决于编译器了。

有的编译器会清，有的编译器不会清，这就太玄学了！

所以，在这中间会生成一个临时变量，来递交给 ret 。

而不是直接用 c 作为返回值，造成非法访问。

所以这里不会直接用 c 作为返回值，而是生成一个临时变量。

那么问题来了，这个临时变量是存在哪里的呢？

① 如果 c 比较小（4或8），一般是寄存器来干存储临时变量的活。

② 如果 c 比较大，临时变量就会放在调用 Add 函数的栈帧中。

总结：所有的传值返回都会生成一个拷贝

（这是编译器的机制，就像传值传参会生成一份拷贝一样）

从C语言到C++②(第一章_C++入门_中篇)缺省参数+函数重载+引用（下）：https://developer.aliyun.com/article/1513637?spm=a2c6h.13148508.setting.21.5e0d4f0emCh6wU

从C语言到C++②(第一章_C++入门_中篇)缺省参数+函数重载+引用（中）

3.引用

3.1引用的概念

3.2引用的特性

3.3引用做参数

3.4 传值返回

热门文章

最新文章

相关课程

相关电子书

相关实验场景