云计算百科
云计算领域专业知识百科平台

C++入门(3)------引用

C++入门之引用

  • 前言
  • 一、引用的概念
    • 1. 初识引用
    • 2. 引用语法: &
    • 3. &的复用
  • 二、引用的特性
    • 1. 引用有哪些特性
  • 三、引用的使用场景和意义
    • 1. 引用做函数参数
      • 1.1 引用做输出型参数
      • 1.2 对象比较大减少拷贝提高效率
    • 2. 引用做函数返回值
      • 2.1 函数返回值的本质
      • 2.2 栈区局部变量不能用引用做函数返回值
      • 2.3 哪些变量可以用引用作为函数返回值
    • 3. 引用与指针
      • 3.1 引用可以替代指针吗
      • 3.2 引用和指针的对比
  • 四、总结

前言

上一章节,小羊结合C语言的相关特性,给介绍了C++的输入输出,函数重载,以及缺省参数几个基础概念. 今天小羊会结合C语言中的指针给老铁们介绍C++中的引用.


一、引用的概念

1. 初识引用

引用: 不是新定义一个变量,而是给已存在变量取一个别名. 编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间。 举个例子: 李逵,在家称"铁牛",江湖人称"黑旋风". 那么铁牛和黑旋风都是李逵的别名.

2. 引用语法: &

引用的语法: & 放在数据类型后面来表示引用.

实例代码如下: 我们定义了变量a, b是a的引用, 是a的别名. 也就是说变量a还有一个名字叫b. 为了验证引用的别名和变量就是一个实体: 我们同时打印变量a和别名b的地址, 会发现二者地址一模一样; 我们给a++, 会发现b也被++. 且我们给变量a可以取多个别名(如b, c), 也可以给别名继续取别名(d). 但是这些别名(b,c,d)最终都跟变量(a)是同一个实体.

#include <iostream>
using std::cout;
using std::endl;
int main()
{
int a = 0;
//引用,b就是a的别名
int& b = a;

//a与b二者地址相同,说明共用一块内存空间
cout << &a << endl; //打印a的地址
cout << &b << endl; //打印b的地址

a++; //a与b都++
cout << a << endl;
cout << b << endl;

int& c = a; //c也是a的别名,别名可以无限取。
int& d = c; //也可以给别名取别名。d是c的别名,bcd都是变量a的别名
return 0;
}

3. &的复用

我相信老铁们在前面见到这个符号 & , 一眼就认出来了. 这不是取地址运算符吗, 有些老铁又说这不是按位与运算符吗. 都没错, 但是用在引用中 & 就不是运算符了, 而是固定语法. 把 & 放在数据类型后表示引用.

今天小羊针对 & 的复用做一个简短的总结, 方便老铁们了解.

  • & 放在一个变量前面是取地址
  • int a = 10;
    int* p = &a;

  • & 放两个整数(表达式)中间是按位与运算符 是位运算符, 将两个整数表达式的结果按照二进制的每一位进行按位与. 对应二进制位,两个都是 1,结果才是 1;否则为 0
  • int a = 3; // 二进制 0011
    int b = 5; // 二进制 0101
    int ret = a & b; //0001 → 结果是 1

  • && 是逻辑与运算符 用于判断两个表达式的结果真假. 全真才真,一假则假. 如果 && 左边表达式为假,右边直接不执行
  • int a = 3;
    int b = 5;
    int c = 0;
    cout << (a && b); // 1,两边都非0,为真
    cout << (a && c); // 0,c是0,为假

  • & 放在数据类型后面是引用 注意&用作引用时, 是语法表示, 不是运算符.
  • int& ref = a; // ref是a的别名

    二、引用的特性

    1. 引用有哪些特性

  • 引用在定义时必须初始化
  • 一个变量可以有多个引用 (即: 一个变量可以取多个别名)
  • 引用不能改变指向 (即: 引用一旦绑定某个实体,就不能再绑定到其他实体.)
  • 引用没有独立的内存空间,和原变量共用同一块内存,地址相同
  • 普通引用不能绑定临时常量和const常量
  • const引用可以绑定临时常量和const常量.
  • #include<iostream>
    using namespace std;
    int main()
    {
    int a = 0;
    int& b = a;
    int& i = a;
    int& j = i; //bij都是a的别名
    int c = 2;
    b = c; //这里是赋值,不是引用取别名
    cout << a << endl;

    int& r = 10; //会报错, 普通引用不能绑定临时右值
    const int y = 10; // y是const常量
    int& r1 = y; //会报错. 普通引用不能const常量
    const int& r2 = 10; //const引用可以绑定临时右值
    const int& r3 = y; //const引用可以绑定const常量
    return 0;
    }

    三、引用的使用场景和意义

    1. 引用做函数参数

    1.1 引用做输出型参数

    输出型参数: 函数通过参数带回结果, 而不是只通过return返回. 拿下面的swap函数举例, 没有返回类型, 但我们想要 swap 函数修改 main 里面的实参 x、y,把交换后的结果带出来, 这就叫输出型参数. 一般在C语言中由传址调用来实现.

    如下代码所示: 第一个交换函数SwapPointer, 由指针实现. 形参是int* a和 int* b. 第二个交换函数SwapCitation, 由引用实现. 形参是int& a和 int&b.

    这两个函数都可以做到输出型参数的功能. 指针我们不必多说. 引用实现的函数, 形参a是实参x的别名,形参b是实参y的别名, ab的交换就是xy的交换. 因为引用和变量本就是同一个实体, 同一个地址.

    #include<iostream>
    using std::cout;
    using std::endl;
    void SwapPointer(int* a, int* b)
    {
    int tmp = *a;
    *a = *b;
    *b = tmp;
    }

    void SwapCitation(int& a, int& b) //a是x的别名,b是y的别名, ab的交换就是xy的交换
    {
    int tmp = a;
    a = b;
    b = tmp;
    }

    int main()
    {
    int x = 0, y = 1;
    SwapPointer(&x, &y);
    cout << x << endl;
    cout << y << endl;
    SwapCitation(x, y);
    cout << x << endl;
    cout << y << endl;
    return 0;
    }

    1.2 对象比较大减少拷贝提高效率

    我们定义了一个结构体类型A, 他的结构成员是一个大小为40000字节的数组a. 我们写了两个测试函数: TestFunc1是传值调用: 形参就是结构体变量a. TestFunc2是引用函数: 形参是结构体变量的别名a.

    我们了解传值调用, 形参是实参的拷贝. 也就是说如果我们调用TestFunc1函数,我们就需要再开辟一块可以容纳至少40000个字节的形参空间来拷贝实参. 但是如果我们调用TestFunc2函数, 形参a是实参a的别名, 而是是同一个实体, 不存在拷贝的问题.

    在下面的函数里我们计算了循环调用10000次TestFunc1函数的时间, 结果是7s. 我们还计算了循环调用10000次TestFunc2函数的时间, 结果是0s. 所以可以得出结论当拷贝对象过大的时候,我们可以用引用作为函数参数, 减少拷贝, 提高效率.

    #include<iostream>
    #include <time.h>
    using namespace std;
    struct A { int a[10000]; };
    void TestFunc1(A a) { }
    void TestFunc2(A& a) { }
    void main()
    {
    A a;
    //以值作为函数参数
    size_t begin1 = clock();
    for (size_t i = 0; i < 10000; ++i)
    {//传值传参10000次, 形参要拷贝10000次实参, 每次都要拷贝40000字节
    TestFunc1(a);
    }
    size_t end1 = clock();

    //以引用作为函数参数
    size_t begin2 = clock();
    for (size_t i = 0; i < 10000; ++i) //这里只用了别名
    {
    TestFunc2(a);
    }
    size_t end2 = clock();

    //分别计算两个函数运行结束后的时间
    cout << "TestFunc1(A)-Time:" << end1 – begin1 << endl;
    cout << "TestFunc1(A&)-Time:" << end2 – begin2 << endl;
    }

    2. 引用做函数返回值

    2.1 函数返回值的本质

    我们首先清楚函数返回值的本质. 下面代码中: 函数返回值是a, main函数用调用语句int ret = func(); 并不是把a赋值给ret. 因为调用函数func,当func销毁时,变量a也跟着销毁了. 函数调用本质上不是把a的值传给main,而是先把a的值拷贝到返回值寄存器中,然后销毁函数栈帧,main函数从寄存器中拿值.

    int func()
    {
    int a = 0;
    return a;
    }
    int main()
    {
    int ret = func(); //并不是把a赋值给ret. main函数从返回值寄存器中拿值
    return 0;
    }

    2.2 栈区局部变量不能用引用做函数返回值

    函数返回值如果是引用, 意味着返回的是函数返回变量的别名.

    函数func1的返回值是变量a的引用, 变量a与a的引用是同一个地址, 同一块空间, 调用func1函数后, 函数栈帧会被释放, 相应的变量 a 的空间也被释放. 那么我们在main函数中进行引用’int& ret = func1();’ 就是野引用 (悬垂引用).

    刚退出函数的时候,当然a的空间已经被释放归还系统, 但a的值还在这块空间内,如果函数结束, 后续别的函数调用同或者局部变量可能会覆盖这块空间. 我们读取到的值可能就不是0.

    #include<iostream>
    using namespace std;
    //函数返回值是a的别名, 函数栈帧在调用完之后会被释放, a的别名与a是同一个东西
    //a的空间已经被释放, 再去取a的值赋值给ret意味着还是在访问这块已经释放的空间.
    //当然a的空间已经被释放归还系统,但a的值还在这块空间内,如果函数结束,后续别的函数调用同或者局部变量可能会覆盖这块空间. 我们读取到的值可能就不是0.
    int& func1() //传引用返回,返回的是返回值变量a的别名
    {
    int a = 0;
    return a;
    }
    int main()
    {
    int& ret = func1();
    //野引用. 因为func返回值是a的别名, 这里ret是a的别名的别名. 但是函数栈帧已经被销毁,空间已经被释放
    cout << ret << endl;
    return 0;
    }

    2.3 哪些变量可以用引用作为函数返回值

    先说结论: 栈区局部变量出了函数作用域就会被销毁, 因此栈区局部变量的引用不可以作为函数返回值. 相应的静态区变量 堆上的变量 类的成员变量 等可以用引用作为函数的返回值返回. 小羊给出的解决方案是**使用static关键字**, 将局部变量从栈区放进静态区, 延长其生命周期, 让变量出了函数也不会被销毁.

    #include<iostream>
    using namespace std;
    int& func() //传引用返回,返回的是返回值变量a的别名
    {
    static int a = 0; //a不在func函数的栈帧内,而是在静态区
    return a;
    }

    int main()
    {
    int& ret = func();
    cout << ret << endl; //可以发现ret作为a的别名,在静态区中存储,不会随函数调用而被销毁
    return 0;
    }

    3. 引用与指针

    3.1 引用可以替代指针吗

    先说结论: 引用不能完全代替指针.

    因为指针的指向可以进行改变,但是引用的指向不能被改变。

    举个例子在我之前介绍的双向链表实现中,当我们进行pop操作想删除掉链表中间一个节点时,节点结构体中next指针和prev指针的指向需要发生改变, 链接前后节点, 继续形成来年表结构. 如果我们使用引用,引用的指向不能被改变,就无法实现pop后的双向链表的复原操作。

    总的来说:C++的引用本质上的目的是对指针使用比较复杂的场景进行一些替换,让代码更简单。

    3.2 引用和指针的对比

    1.语法的角度进行对比:

    1.1 引用是别名, 语法上不用额外开辟空间; 指针是地址,需要开辟空间存储
    引用在底层也是用指针实现的, 引用的语法含义与底层实现是背离的, 就像鱼香肉丝没有鱼一样.

    1.2 引用必须初始化, 指针可以初始化,也可以不初始化. 这倒也是为什么野指针出现较为频繁的原因

    1.3 他们最大的区别还是引用不可以改变指向, 但是指针可以改变指向

    1.4 引用相对更安全, 没有空引用,但是有空指针. 容易出现野指针, 但不容易出现野引用

    1.5 在sizeof中的含义不同: sizeof(引用)结果为引用类型的大小, sizeof(指针)始终是地址所占的字节数(4,8字节)

    1.6 引用++是引用的实体+1, 指针++是指针向后偏移一个类型的大小

    1.7 有多级指针, 没有多级引用

    1.8 访问方式不同, 指针要显示解引用, 引用则有编译器自己处理.

    2.用法和底层的角度进行对比:

    从汇编层度上考量, 没有引用, 都是指针. 引用编译后也转换成指针了.

    int main()
    {
    int a = 10;
    int& ra = a; //语法上不开空间, 底层汇编代码显示开空间. 引用在底层也是用指针实现的
    ra = 20;

    int* pa = &a; //语法上开空间, 底层也开空间
    *pa = 30;
    return 0;
    }

    四、总结

    小羊结合指针给老铁们介绍了引用的概念, 用法, 特性, 使用场景和意义. 同时也对比引用和指针的意义. 相信看完后大家会对引用有一个初步而全面的了解. 正式跨入C++的大门.

    赞(0)
    未经允许不得转载:网硕互联帮助中心 » C++入门(3)------引用
    分享到: 更多 (0)

    评论 抢沙发

    评论前必须登录!