C++基础入门（引用补充）

komorebi-filpped

已于 2023-02-04 00:26:55 修改

阅读量913

点赞数 23

分类专栏： C++ 文章标签： c++ Powered by 金山文档

于 2023-02-02 03:32:27 首次发布

本文链接：https://blog.csdn.net/m0_64388758/article/details/128843030

版权

C++ 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1、使用场景

做参数

void Swap(int& left, int& right)
{
   int temp = left;
   left = right;
   right = temp;
}

做返回值

int& Count()
{
   static int n = 0;
   n++;
   // ...
   return n;
}

c语言内，出了count函数，n被销毁，会创建临时变量存储其值，销毁不代表该空间全部销毁，如果实在想访问该空间，也是可以访问的，有可能是非法访问，但是不一定报错（类比数组越界）

}

静态数据n不会被销毁，但是按照流程也会创建临时变量去存储其值后在赋值给ret,由于n并未被销毁，我们可以进行优化，C++可以直接引用

临时变量只读，不能修改

引用返回

减少拷贝

调用者可以修改返回对象

int& Count()
{
    static int n = 0;
    n++;

    return n;
}

#define N 10
typedef struct Array
{
    int a[N];
    int size;
}AY;

int& PosAt(AY& ay, int i)
{
    

    return ay.a[i];
}

int main()
{
    int ret = Count();

    AY ay;
    for (int i = 0; i < N; ++i)
    {
        PosAt(ay, i) = i*10;
    }

    for (int i = 0; i < N; ++i)
    {
        cout << PosAt(ay, i) << " ";
    }
    cout << endl;
    

    return 0;
}

观察下列代码

int& Add(int a, int b)
{
    int c = a + b;
    return c;
}
int main()
{
    int& ret = Add(1, 2);
    Add(3, 4);
    cout << "Add(1, 2) is :"<< ret <<endl;
    return 0;
}

第一次退出栈帧后若未清理，则返回7，如果清理，返回随机值

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用

引用返回，如果已经还给系统了，则必须使用传值返回。

如果修改为int ret=Add(1,2);去掉引用，则将返回值拷贝给ret，也要考虑出栈后数据的清理

2、传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直

接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效

率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低

#include <time.h>
struct A { int a[10000]; };
A a;

A TestFunc1() { return a; }
// 引用返回
A& TestFunc2(){ return a; }

void TestReturnByRefOrValue()
{
    // 以值作为函数的返回值类型
    size_t begin1 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc1();
    size_t end1 = clock();

    // 以引用作为函数的返回值类型
    size_t begin2 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc2();
    size_t end2 = clock();

    // 计算两个函数运算完成之后的时间
    cout << "TestFunc1 time:" << end1 - begin1 << endl;
    cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

int main()
{
    TestReturnByRefOrValue();

    return 0;
}

3、权限

指针和引用，赋值/初始化权限可以缩小，但是不能放大

int main()
{
    int a = 1;
    int& b = a;

    // 指针和引用，赋值/初始化 权限可以缩小，但是不能放大

    // 权限放大
    /*const int c = 2;
    int& d = c;

    const int* p1 = NULL;
    int* p2 = p1;*/

    // 权限保持
    const int c = 2;
    const int& d = c;

    const int* p1 = NULL;
    const int* p2 = p1;

    // 权限缩小
    int x = 1;
    const int& y = x;

    int* p3 = NULL;
    const int* p4 = p3;

    // 赋值，m值拷贝给n
    //const int m = 1;
    //int n = m;
    
    //临时变量不可修改
    const int& ret = Count();

    int i = 10;

    cout << (double)i << endl;//产生临时变量，且临时变量为double类型

    double dd = i;

    //相当于创建一个double类型的临时变量dd，权限放大，前加const，只读权限
    const double& rd = i;

    return 0;
}

临时变量具有常性，不能修改

int Count()
{
    int n = 0;
    n++;

    return n;
}

int main()
{
    int& ret = Count();
    return 0;
}

int Count()
{
    int n = 0;
    n++;

    return n;
}

int main()
{
    //权限保持
    const int& ret = Count();
    return 0;
}

4、引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间

int main()
{
int a = 10;
int& ra = a;
cout<<"&a = "<<&a<<endl;
cout<<"&ra = "<<&ra<<endl;
return 0;
}

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}

我们来看下引用和指针的汇编代码对比

引用和指针的不同点:33333

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何

一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32

位平台下占4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全

5、内联函数

//C++推荐
 //const和enum替代宏常量
 //inline去替代宏函数

 //宏缺点：
 //1、不能调试
 //2、没有类型安全的检查
 //3、有些场景下非常复杂,容易出错，不容易掌握

 //要求实现ADD宏函数
//#define ADD(int x, int y) return x+y;
//#define ADD(x, y) x+y;
//#define ADD(x, y) (x+y)
//#define ADD(x, y) (x)+(y)
//#define ADD(x, y) ((x)+(y));

#define ADD(x, y) ((x)+(y))//正确的
//#define ADD(x, y) (x + y)
//#define ADD(x, y) (x)+(y)
//#define ADD(x, y) x+y


int main()
{
    ADD(1, 2) * 3; // ((1)+(2))*3;

    int a = 1, b = 2;
    ADD(a | b, a & b); // ((a | b) + (a & b));;

    return 0;
}

概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调

用建立栈帧的开销，内联函数提升程序运行的效率。

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

查看方式：

1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add

2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不

会对代码进行优化，以下给出vs2019的设置方式)

右键下图蓝色区域

点击属性

配置

特性

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会

用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运

行效率。

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建

议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不

是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为

《C++prime》第五版关于inline的建议：

3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址

了，链接就会找不到

// F.h
#include <iostream>
using namespace std;
inline void f(int i);
// F.cpp
#include "F.h"
void f(int i)
{
 cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
 f(10);
 return 0;
}
// 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl 
f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用

不使用内联函数，该代码能运行，其遇到函数后跳到函数地址再进行建立，压栈等一系列操作，但是内联函数默认展开，包含头文件，头文件内只有声明，无法展开函数内容