• 引用类型必须和引用实体的类型相同。

注意：

int a = 10；int& ra = a;    //只是引用int* pra = &a;  //这是取地址

8.2引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体。

int main(){int a = 10;//int& ra;   //没有初始化，该条语句编译时会报错int& ra = a;int& rra = a;printf("%p %p %p %d\n", &a, &ra, &rra, ra);int b = 20;ra = b;//b的值赋值给a，引用后无法在修改引用的实体printf("%p %p %p %p %d %d\n", &a, &ra, &rra,&b,ra,a);return 0;}

8.3常引用

常引用即为在变量类型前修饰const使其不能修改，这就使得被修饰的变量只能读，没办法写。造成了被const修饰的变量无法被未被修饰的引用接收，因为未修饰const的引用可以修改自身的值而被修饰的不能，看如下例子：

void TestConstRef(){    //权限的放大const int a = 10;int& ra = a;  //该语句编译时会出错，a为常量不能修改，ra的类型为int可以修改，此时无法通过        int& b = 10;  //该语句编译时会出错，10为常量不能修改，b为int类型，可以修改，产生矛盾const int& b = 10;        //权限不变    const int& ra = a;//权限不变是可以的        //权限缩小    int e = 30;    const int& re = e;//权限缩小也是可以的}

对于常引用，它的权限就是读、写，权限只能被缩小不能被放大

a是常量，无法被ra接收，如果可以接收，ra就可以修改a，将原本只能写的权限放大，即可读也可写。这产生本质上的错误，故权限不能放大

---

b易是同理，在没有被const修饰前，既能读也能写，而常量10只能读，不能接收10。
b被const修饰后，和常量的权限相同，可以接收常量

---

e的没有被修饰，可读可写，当它被re接收后，re可以读出e，这对e没有影响，re接收的只是e的部分权限，故权限可以缩小。

1.应用：

void f(const int& x){cout << x << endl;}

观察如上代码，当我们学习的更多，要去使用x接收一个大的对象时，我们就要尽量使用引用，减少拷贝，如果要求在函数f()中不改变该对象，就建议尽量用const引用传参，从而不会改变x的值。

2.引用对于缺省参数

void Add(const int& a=10){}

像这样的缺省参数或是类似传递常量的函数，在使用引用时必须使用const否则无法无法接收，编译器报错。

3.不同类型的引用

int main(){double d = 12.34;    int i = d;//int& rd = d;  //该语句编译时会出错const int& rd = d;    return 0;}

为什么int& rd = d;会出错，而int i = d;和const int& rd = d;却可以

• 一个是被产生的临时变量赋值，一个是引用产生的临时变量（共用同一块地址）

printf("double:%p\n", &d);printf("const int:%p\n", &rd);

8.4使用场景

1. 做参数

   这里我们实现一个简单的两数交换函数。

   //传引用void Swap(int& left, int& right){int temp = left;left = right;right = temp;}//传地址void Swap(int *left, int *right){int temp = *left;*left = *right;*right = temp;}int main(){int a = 10;int b = 20;Swap(a,b);cout << "a=" << a << "，" << "b=" << b << endl;    //Swap1(&a,&b);    return 0;}

   

   • 两个Swap参数不同，构成函数重载。

   • 如果再加一个传值的Swap函数（如下），也可形成函数重载，但在调用时会产生歧义，编译器报错

     void Swap(int a,int b);

2. 做返回值

   我们先来看下面图片中的代码：

   

   根据上述代码可知，编译器不会直接将Add函数内c的值直接返回，而是通过临时变量。

   临时变量在哪呢？

   1. 返回值小（4~8个字节）：一般是寄存器充当临时变量
   2. 返沪值较大：临时变量放在调用Add函数的栈帧中

   总之：所有的传值返回都会生产一个拷贝。

   我们再来看看下面使用引用返回：

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

   

   当前代码的问题：

   1. 存在非法访问，因为Add(1,2)的返回值是c的引用，所以Add栈帧销毁了以后，回去访问c位置空间
   2. 如果Add函数栈帧销毁，那么取c值得时候取到就是随机值，给ret就是随机值，取决于编译器是否清理Add函数被销毁的空间。（vs下销毁栈帧，不会清理数据，所以可以得到结果）

   原因：

   • 之所以得到这样的结果，因为返回的是c这一地址的引用，由ret接收，此时ret的地址就是c的地址，而c所在函数是被销毁，并没有被清理，数据依然存在。调用两次Add函数，函数栈帧没有改变，c的地址也没有改变，每次都是c变量这一地址所存储的值发生变化，所以ret随之发生变化。
   • 所以我们不要随意用引用返回，可能会造成非法的访问。

   总结：

   如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

8.5传值、传引用效率比较

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

struct A {int a[10000];};void TestFunc1(A a){}void TestFunc2(A& a){}void TestRefAndValue(){A a;//以值作为函数参数size_t begin1 = clock();for (int i = 0; i < 10000; i++){TestFunc1(a);}size_t end1 = clock();//引用作为函数参数size_t begin2 = clock();for (int 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;}

• 传值是拷贝一份传递
• 传引用是时形参变为实参的别名，实参与形参的地址相同
• 相比之下，直接使用原有地址的数据，要比重新拷贝更快

值和引用的作为返回值类型的性能比较

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 < 100000; ++i)TestFunc1();size_t end1 = clock();    // 以引用作为函数的返回值类型size_t begin2 = clock();for (size_t i = 0; i < 100000; ++i)TestFunc2();size_t end2 = clock();    // 计算两个函数运算完成之后的时间cout << "TestFunc1 time:" << end1 - begin1 << endl;cout << "TestFunc2 time:" << end2 - begin2 << endl;}

• 值返回，返回的是拷贝的一份零时变量的值
• 引用返回，返回的是所存数据地址的别名
• 相比之下引用返回更有优势

总结：

引用的作用主要体现在传参和传返回值：

1. 引用传参和传返回值，有些场景下面，可以提高性能。（大对象、深拷贝对象）
2. 引用传参和传返回值，输出型参数和输出型返回值。通俗点讲，有些场景下面，形参的改变可以改变实参。有些场景下面，引用返回，可以改变返回对象。

8.6引用的作用

1. 提高效率

2. 修改返回变量

   #define N 10int& At(int i){static int a[N];//保证出了作用域，对象还在return a[i];//返回a[i]的引用}int main(){for (int i = 0; i < N; i++){At(i) = 10 + i;//返回值是一个变量，可以直接修改}for (int i = 0; i < N; i++){cout << At(i) << " ";}return 0;}

   

8.7引用和指针的区别

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

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;}

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

引用和指针的不同点：

1. 引用概念上定义一个变量名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求（最好初始化，不初始化也可以）。
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以再如何时候指向任何一个同类型实体。
4. 没有NULL引用，但有NULL指针。
5. 在sizeof中含义不同：引用结果为引用类型大小，但指针始终是地址空间所占字节个数（32位平台下占4个字节）
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
7. 有多级指针，但是没有多级引用。
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
9. 引用比指针使用起来相对安全。

总结： 指针使用起来更复杂，更容易出错。

• 指针和引用的区别面试经常考察，按自己的理解就可以

9.内联函数

9.1问题

在我们学习和工作中总要频繁的去调用一些小函数，如下面的swap函数

int Swap(int& a1, int& a2){int temp = a1;a1 = a2;a2 = temp;}

每次函数的调用都伴随着建立栈帧，栈帧中要保留一些寄存器，结束后又要恢复，可以看到这些都是对时间和空间的消耗。

那么对于这些功能简单、调用次数多的小函数有什么办法可以优化一下吗？

C语言中提供了宏来解决这个问题

//方法1#define SWAP(a,b) \a= a^b;\b= a^b;\a= a^b;//方法2#define SWAP(a,b) \a = a + b; \b = a - b; \a = a - b;

• 不在使用函数，而是在需要的位置，直接替换为宏的表达式。
• 但宏的实现有时又很复杂，所以C++提供了内联函数来解决这个问题

9.2概念：

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开（用函数体替换函数的调用），没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

如下图的Swap即在开辟函数栈帧。

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

我们在debug

查看方法：

1. 在release模式下，查看编译器生成的汇编代码中是否存在call Swap
2. 在debug模式下，需要对编译器进行设置，否则不会展开（因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2019的设置方式）

依次点击应用，确认后

设置好后在来看一下，函数是否展开，是否有call Swap

9.3特性

1. inline是一种以空间换时间（在调用位置替换，不进行函数的栈帧）的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用（将函数的实现换到了call的位置），缺陷：可能使目标文件变大，优势：少了调用开销，提高程序运行效率。

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模小（即函数不是很长，具体没有准确的说法，取决于编译器内部实现），不使递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下面为《C++prime》第五版关于inline的建议：

   • 内联说明只是向编译器发出的一个请求，编译器可以选择忽略这个请求。

   一般来说，内联机制用于优化规模较小、流程直接、频繁调用的函数。很多编译器都不支持内联递归函数，而且一个75行的函数也不大可能在调用点内联地展开。

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

   // F.h#include 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 __cdeclf(int)" (" />
    
     
   改为extern const pst p1;即可，上面的外部的是指声明为extern的常量。
    
    
   在编译时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚的知道表达式的类型。而有时候想要知道表达式的类型不是那么容易。
    
   因此C++11给auto赋予了新的含义
    
   10.2auto简介
    
     
   在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但是一直没有人去使用它。像如下代码：
    
    
   int main(){    auto int a = 0;        return 0;}
   在早期使用auto关键字修饰变量a，表示a是一个局部变量，声明周期在main函数内，可是不适应auto关键字修饰，变量a还是一个局部变量，它的生命周期没有改变，所以auto关键字就失去了意义。
   C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型的知识符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期由等号右边的值推导而得。
   int main(){int a = 0;//自动推导变量的类型auto c = &a;auto d = 'a';auto e = 10.11;map<string, string> m = { {"lisi","李四"},{"zhangsan","张三"} };auto m = m.begin();//typeid可以打印变量的类型cout << typeid(c).name() << endl;cout << typeid(d).name() << endl;cout << typeid(e).name() << endl;cout << typeid(m).name() << endl;//auto e；无法通过编译，使用auto定义变量时必须对其进行初始化return 0;}
   注意： 使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。
   10.3auto的使用细则
   auto与指针和引用结合起来使用
   用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
   int main(){int x = 10;auto a = &x;auto* b = &x;auto& c = x;cout << typeid(a).name() << endl;cout << typeid(b).name() << endl;cout << typeid(c).name() << endl;*a = 20;cout << x << endl;*b = 30;cout << x << endl;c = 40;cout << x << endl;return 0;}
   在同一行定义多个变量
   当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
   10.4auto不能推导的场景
   auto不能作为函数的参数
   //auto不能作为形参类型，因为编译器无法对a的实际类型进行推导，此处代码编译失败void Test(auto a){}
   auto不能直接用来声明数组，数组需要根据元素类型及个数来开辟空间，而数组名代表指针，因此auto无法推导
   void Test(){    int a[] = {1,2,3};    auto b[] = {4,5,6};//不能这样使用}
   为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法。
   auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用。
   11.基于范围的for循环（C++11）
   11.1范围for的语法
   在C++98当中如果要遍历一个数组，可以按照以下方式进行：
   void Test(){int arr[] = { 1,2,3,4,5,6,7 };for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++){cout << arr[i] << " ";}cout << endl;for (int* ptr = arr; ptr < arr + sizeof(arr)/sizeof(arr[0]); ptr++){cout << *ptr << " ";}cout << endl;}
   对于一个有范围的集合而言，由程序员来说明循环的范围式多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ : ”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
   void Test(){int arr[] = { 1,2,3,4,5,6,7 };for (auto& e : arr){cout << e << " ";e *= 2;}cout << endl;for (auto e : arr) // 自动依次取数组arr中的每个元素赋值给e{e *= 2;cout << e << " ";}cout << endl;for (auto e : arr){cout << e << " ";}cout << endl;}
   注意： 与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环
   两种写法
   不使用引用
   for (auto e : arr) {cout << e << " ";}
   自动依次取数组arr中的每个元素赋值给e，e得到的只是arr中的每个元素值，无法数组进行修改
   auto e = arr;(arr依次循环一圈)
   使用引用
   for (auto& e : arr) {e++;}
   自动依次使数组arr中的每个元素的别名为e，这样我们修改e就是修改数组中对应的值
   auto& e = arr;(arr依次循环一圈)
   11.2范围for的使用条件
   for循环迭代的范围必须是确定的
   对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
   注意： 下面的代码就要问题，因为for的范围不确定
   void Test(int arr[]){    for(auto& e : arr)    cout << e << endl}
   范围for中的arr必须是数组名，数组名传参给函数是会变为指针。
   迭代的对象要实现++和==的操作
   12.指针空值nullptr(C++11)
   12.1C++98中的指针空值
   在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针（造成野指针）。如果一个指针没有合法的指向，我们基本都会按照如下方式对其进行初始化。
   void TestPtr(){int* ptr1 = NULL;int* ptr2 = 0;}
   NULL实际是一个宏，在传统的C头文件中，可以看到如下代码：
   #ifndef NULL#ifdef __cplusplus#define NULL 0#else#define NULL ((void *)0)#endif#endif
   可以看到，对于c语言，NULL可能被定义为字面常量0，或者被定义为无类型指针（void*）的常量 。 但在C++中，NULL代表的就是0。虽然0和((void*)0)在数值上表示相同，但它们的类型不同，一个是整形，一个是指针。在C++中使用指针时需要的时指针类型，这就导致NULL在C++中出现了如下问题，NULL指针无法发挥它的作用。
   void f(int)//当函数中不使用形参时，可以直接写一个参数类型{cout<<"f(int)"<<endl;}void f(int*){cout<<"f(int*)"<<endl;}int main(){    f(0);    f(NULL);//此处NULL本意调用指针类型    f((int*)NULL);    return 0;}
   程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
   在C98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void*)0。
   为了解决这个问题，C++11提出了指针空值nullptr，同时认为nullptr就是(void*)0
   12.2C++11中的指针空值
   指向如下代码：
   void f(int){    cout << "f(int)" << endl;}void f(int*){    cout << "f(int*)" << endl;}int main(){    f(0);    f(NULL);    f(nullptr);    return 0;}
   使用C++11中的指针空值nullptr，默认表示指针，而非0.
   注意：
   在使用nullptr表示指针空值时，不要包含头文件，因为nullptr是C++11作为新关键字引入的。
   在C++11中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同。
   为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
   相关文章
     
    常用SQL语句大全实例总结-基础篇
     
    C++语言执行标准
     
    【C语言】循环语句for
     
    光鉴科技的反卷思维，让科技不再难做
     
    Django用户访问日志记录插件[django_user_visit 2.0]汉化
     
    炒黄金所需的k线图基础知识（上）
     
    NFT 的洗盘交易，真的赚钱吗？
     
    揭秘｜来看看袋鼠云数栈内部的资产血缘方案设计与实现
   最新关注
    【MySQL】InnoDB存储引擎
    DB-GPT：强强联合Langchain-Vicuna的应用实战开源项目，彻底改变与数据库的交互方式
    TigerBeetle：世界上最快的会计数据库
    【SQL server】玩转SQL server数据库：第三章 关系数据库标准语言SQL（二）数据查询
    马斯克400条聊天记录被法院公开，原来推特收购是在短信上谈崩的
    戏精摩根大通：从唱空比特币到牵手贝莱德
   热文推荐
    
    MySQL – 事务日志
    
    NewBing、Andi、Phind、Perplexity 还有国产kuaisou五个AI搜索引擎的介绍和对比
    
    如何在nginx上设置html不缓存
    
    LInux系统架构—-Apache与Nginx动静分离
    
    Python使用pywebview开发桌面应用：打造现代化、跨平台的用户体验
    
    如何解决sms-activate的解决问题
    MaxSSL