锐客网

  1. 首页 > it技术 > >

带你了解C++初阶之引用

目录

  • 一、 引用概念
  • 二、 引用特性
  • 三、 常引用
  • 四、 使用场景
    • 1、做参数
      • 指针
      • 引用
    • 2、做返回值
      • 2.1、传值返回
      • 2.2、传引用返回
    • 小结引用做返回值
    • 五、函数参数及返回值 —— 传值、传引用效率比较
      • 六、 引用和指针的区别
        • 1.语法概念
          • 2.底层实现
          • 总结

            一、 引用概念 引用不是新定义一个变量，而是给已存在变量取了一个别名，语法理解上程序不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间
            比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"
            带你了解C++初阶之引用
            文章图片

            类型& 引用变量名(对象名) = 引用实体
            int main(){ //有一块空间a,后面给a取了三个别名b、c、d int a = 10; int& b = a; int& c = a; int& d = b; //char& d = a; //err,引用类型和引用实体不是同类型(这里有争议————char a = b[int类型],留个悬念,下面会解答) //会被修改 c = 20; d = 30; return 0; }

            注意
            • 引用类型必须和引用实体是同种类型
            • 注意区分 ‘&’ 取地址符号

            二、 引用特性
            • 引用在定义时必须初始化
            • 一个变量可以有多个引用
            • 引用一旦引用一个实体，再不能引用其他实体
            int main(){ //int& e; //err int a = 10; int& b = a; //这里指的是把c的值赋值于b int c = 20; b = c; return 0; }


            三、 常引用
            void TestConstRef(){ const int a = 10; //int& ra = a; //该语句编译时会出错，a为常量; 由const int到int const int& ra = a; //ok int b = 20; const int& c = b; //ok,由int到const int //b可以改,c只能读不能写 b = 30; //c = 30; //err //b、c分别起的别名的权限可以是不变或缩小 int& d = b; //ok //int& e = c//err const int& e = c; //ok //int& f = 10; // 该语句编译时会出错，b为常量 const int& g = 10; //ok int h = 10; double i = h; //ok //double& j = h; //err const double& j = h; //ok //?为啥h能赋值给i了(隐式类型转换)，而给h起一个double类型的别名却不行————如果是仅仅是类型的问题那为啥加上const就行了？ //double i = h; 并不是直接把h给i,而是在它们中间产生了一个临时变量(double类型、常量),并利用这个临时变量赋值 //也就是说const double& j = h; 就意味着j不是直接变成h的别名,而是变成临时变量(doublde类型)的别名,但是这个临时变量是一个常量,这也解释了为啥需要加上const}

            小结
            1.我能否满足你变成别名的条件：可以不变或者缩小你读写的权限 (const int -> const int 或 int -> const int)，而不能放大你读写的权限 (const int -> int)
            2.别名的意义可以改变，并不是每个别名都跟原名有一样的权限
            3.不能给类型不同的变量起别名的真正原因不是类型不同，而是隐式类型转换后具有常性了
            常引用的意义 (举例栈)
            typedef struct Stack{ int* a; int top; int capacity; }ST; void InitStack(ST& s)//传引用是为了形参的改变影响实参{//...}void PrintStack(const ST& s)//1.传引用是为了减少拷贝 2. 同时保护实参不会被修改{//...}void Test(const int& n)//即可以接收变量，也可以接收常量{//...}int main(){ ST st; InitStack(st); //... PrintStack(st); int i = 10; Test(i); Test(20); return 0; }

            小结
            1.函数传参如果想减少拷贝使用引用传参，如果函数中不改变这个参数最好使用 const 引用传参
            2.const 引用的好处是保护实参，避免被误改，且它可以传普通对象也可以传 const 对象

            四、 使用场景
            1、做参数
            void Swap1(int* p1, int* p2){ int temp = *p1; *p1 = *p2; *p2 = temp; }void Swap2(int& rx, int& ry){ int temp = rx; rx = ry; ry = temp; }int main(){ int x = 3, y = 5; Swap1(&x, &y); //C传参 Swap2(x, y); //C++传参 return 0; }

            在 C++ 中形参变量的改变，要影响实参，可以用指针或者引用解决
            意义：指针实现单链表尾插 || 引用实现单链表尾插

            指针 带你了解C++初阶之引用
            文章图片


            引用
            void SListPushBack(SLTNode*& phead, int x){ //这里phead的改变就是plist的改变}void TestSList2(){ SLTNode* plist = NULL; SListPushBack(plist, 1); SListPushBack(plist, 2); }

            有些书上喜欢这样写 (不推荐)
            typedef int SLTDataType; typedef struct SListNode{ SLTDataType data; struct SListNode* next; }SLTNode, *PSLTNode; void SListPushBack(PSLTNode& phead, int x){ //...}


            2、做返回值

            2.1、传值返回
            //传值返回int Add(int a, int b){ int c = a + b; return c; //需要拷贝}int main(){ int ret = Add(1, 2); //ok, 3 Add(3, 4); cout << "Add(1, 2) is :"<< ret <
            Add 函数里的 return c; —— 传值返回，临时变量作返回值。如果比较小，通常是寄存器；如果比较大，会在 main 函数里开辟一块临时空间
            怎么证明呢
            int Add(int a, int b){ int c = a + b; return c; }int main(){ //int& ret = Add(1, 2); //err const int& ret = Add(1, 2); //ok, 3 Add(3, 4); cout << "Add(1, 2) is :"<< ret <
            从上面就可以验证 Add 函数的返回值是先存储在临时空间里的

            2.2、传引用返回
            //传引用返回int& Add(int a, int b){ int c = a + b; return c; //不需要拷贝}int main(){ int ret = Add(1, 2); //err, 3 Add(3, 4); cout << "Add(1, 2) is :"<< ret <
            结果是不确定的，因为 Add 函数的返回值是 c 的别名，所以在赋给 ret 前，c 的值到底是 3 还是随机值，跟平台有关系 (具体是平台销毁栈帧时是否会清理栈帧空间)，所以这里的这种写法本身就是越界的 (越界抽查不一定报错)、错误的
            发现这样也能跑，但诡异的是为啥 ret 是 7
            //传引用返回int& Add(int a, int b){ int c = a + b; return c; }int main(){ int& ret = Add(1, 2); //err, 7 Add(3, 4); cout << "Add(1, 2) is :"<< ret <
            在上面我们在 VS 下运行，可以得出编译器并没有清理栈帧，那么这里进一步验证引用返回的危害
            虽然能正常运行，但是它是有问题的
            带你了解C++初阶之引用
            文章图片


            小结引用做返回值
            1.出了 TEST 函数的作用域，ret 变量会销毁，就不能引用返回
            2. 出了 TEST 函数的作用域，ret 变量不会销毁，就可以引用返回
            3.引用返回的价值是减少拷贝
            观察并剖析以下代码
            int main()int main(){ int x = 3, y = 5; int* p1 = &x; int* p2 = &y; int*& p3 = p1; *p3 = 10; p3 = p2; return 0; }

            带你了解C++初阶之引用
            文章图片


            五、函数参数及返回值 —— 传值、传引用效率比较
            #include #includeusing namespace std; struct A { int a[10000]; }; A a; void TestFunc1(A a) {}void TestFunc2(A& a) {}A TestFunc3() { return a; }A& TestFunc4() { return a; }void TestRefAndValue(){A a; // 以值作为函数参数size_t begin1 = clock(); for (size_t i = 0; i < 10000; ++i)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 << "TestFunc2(A&)-time:" << end2 - begin2 << endl; }void TestReturnByRefOrValue(){// 以值作为函数的返回值类型size_t begin1 = clock(); for (size_t i = 0; i < 100000; ++i)TestFunc3(); size_t end1 = clock(); // 以引用作为函数的返回值类型size_t begin2 = clock(); for (size_t i = 0; i < 100000; ++i)TestFunc4(); size_t end2 = clock(); // 计算两个函数运算完成之后的时间cout << "TestFunc1 time:" << end1 - begin1 << endl; cout << "TestFunc2 time:" << end2 - begin2 << endl; }int main(){//传值、传引用效率比较TestRefAndValue(); cout << "----------cut----------" << endl; //值和引用作为返回值类型的性能比较TestReturnByRefOrValue(); return 0; }#include #includeusing namespace std; struct A { int a[10000]; }; A a; void TestFunc1(A a) {}void TestFunc2(A& a) {}A TestFunc3() { return a; }A& TestFunc4() { return a; }void TestRefAndValue(){ A a; // 以值作为函数参数 size_t begin1 = clock(); for (size_t i = 0; i < 10000; ++i)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 << "TestFunc2(A&)-time:" << end2 - begin2 << endl; }void TestReturnByRefOrValue(){ // 以值作为函数的返回值类型 size_t begin1 = clock(); for (size_t i = 0; i < 100000; ++i)TestFunc3(); size_t end1 = clock(); // 以引用作为函数的返回值类型 size_t begin2 = clock(); for (size_t i = 0; i < 100000; ++i)TestFunc4(); size_t end2 = clock(); // 计算两个函数运算完成之后的时间 cout << "TestFunc1 time:" << end1 - begin1 << endl; cout << "TestFunc2 time:" << end2 - begin2 << endl; }int main(){ //传值、传引用效率比较 TestRefAndValue(); cout << "----------cut----------" << endl; //值和引用作为返回值类型的性能比较 TestReturnByRefOrValue(); return 0; }

            以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低

            六、 引用和指针的区别
            1.语法概念
            引用就是一个别名，没有独立空间，和其引用实体共用同一块空间
            指针变量是开辟一块空间，存储变量的地址
            int main(){ int a = 10; int& ra = a; cout<<"&a = "<<&a<
            文章图片

            引用和指针的不同点：
            1、引用在定义时必须初始化，指针没有要求
            2、引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
            3 、没有 NULL 引用，但有 NULL 指针
            4、在 sizeof 中含义不同：引用结果为引用类型的大小，与类型有关；但指针始终是地址空间所占字节个数 (32 位平台下占 4 个字节，64 位平台下占 8 个字节)，与类型无关
            5、引用自加即引用的实体增加 1，与类型无关，指针自加即指针向后偏移一个类型的大小，与类型有关
            6、有多级指针，但是没有多级引用
            7、访问实体方式不同，指针需要解引用，引用编译器自己处理
            8、引用比指针使用起来相对更安全，指针容易出现野指针、空指针等非法访问问题

            总结 【带你了解C++初阶之引用】本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注脚本之家的更多内容!

              推荐阅读


              上一篇：Java实现班级管理系统

              下一篇：带你从编码角度分析C++重载原理