C++——引用内联函数

Posted 2022-12-08 一棵灬胡杨树

文章目录

• 一、引用是什么？
• • 1.1 引用的特性
  • 1 .2常引用(对const的引用)
  • 1.3 引用的使用场景
  • 1.4 传值、传引用效率比较
  • 1.5 引用和指针的区别
• 二、内联函数
• • 1.什么是内联函数
  • 2.内联函数的特性
• 三、auto关键字(C++11)
• • auto的使用细则

---

一、引用是什么？

引用不是一个新的变量，而是给已经存在的变量取了一个别名，编译器不会为引用变量开辟新的内存空间，引用和被引用的变量共用一块内存空间。

引用（reference）为对象起了另外一个名字，引用类型引用另外一种类型。通过将声明符写成&d的形式来定义引用类型，其中d是声明的变量名:

    int val = 100;
    int &refval = val;//refval指向val（是val另一个名字）
    int &refval2;//会报错：引用必须被初始化。

1.1 引用的特性

1.引用必须被初始化
Q1:为什么引用必须初始化？
一般在初始化变量时，初始值会被拷贝到新建的对象中。然而定义引用时，程序把引用和它的初始值绑定在一起，而不是将初始值拷贝给引用。一旦初始化完成，引用将一直和它的初始值对象一直绑定在一起。因为无法令引用重新绑定到另一个对象，因此引用必须初始化。
2.一个变量可以有多个引用
3.引用一旦引用一个实体，再不能引用其他实体

   int val = 10;
   int val_1 = 20;
   int &ra = val;
   int &ra = val_1;//会报错：因为ra已经与val绑定,再不能引用其他实体。
   int &rra = val;//一个实体(变量)可以有多个引用

Notes:在C++11中新增了一种引用：所谓的“右值引用”。这种引用主要用于内置类。严格来说，当我们使用术语“引用”时，指的其实是“左值引用”。

1 .2常引用(对const的引用)

在基本引用中，所有的引用类型都要和与之绑定的对象严格匹配（有例外）。而且，引用只能绑定在对象上，而不能与字面值或者某个表达式的计算结果绑定在一起。

   const int a = 10;
   int &ra = a;//错误：a为常量
   const int &ri = a;//正确：引用以及其对应的对象都是常量。

   const int a = 10;
   int &ra = a;//错误：a为常量
   const int &ri = a;//正确：引用以及其对应的对象都是常量。
   ri = 42;//错误：ri是对常量的引用
   int &rb = a;//错误：试图让一个非常量引用指向一个常量对象。

在上文中提到：引用的类型必须与其所引用的对象的类型一致，但是有例外。第一种例外就是在初始化常量引用时允许用任意表达式作为初始值，只要该表达式的结果能转换成引用的类型即可。

我们可以来看看当一个常量引用被绑定到另外一种类型上时到底发生了什么：

   double d = 12.34;
   //int &rd = d;//错误:因为类型不同
   const int& rd = d;//为什么就正确了？

此处rd引用了一个int类型的整数。对rd的操作应该是整数运算符，但d却是一个双精度浮点数而非整数。因此为了确保让rd绑定一个整数，编译器把上述代码变成了如下形式:

   const int temp = d;//由双精度浮点数生成一个临时的整形常量
   const int& rd = temp;//让rd绑定这个常量

在这种情况下，rd绑定了一个临时量对象。所谓的临时量对象就是当编译器需要一个空间来暂存表达式的求值结果时创建的一个未命名的对象。注意，此时rd绑定的对象是一个临时量而非d。

1.3 引用的使用场景

1.做参数

void Swap(int& left,int& right)

    int tmp = left;
    left = right;
    right = tmp;

2.做返回值

int& Count()

    static  int n = 0;
    n++;
    //.....
    return n;

Q:看看下面代码的结果是什么？

#include <iostream>
using namespace std;
int& Add (int a,int b)

    int c = a + b;
    return c;

int main()

    int& ret = Add(1,2);
    Add(3,4);
    std::cout<<"Add(1,2) = "<<ret<<endl;
    return 0;

注意：如果函数返回时，出了函数的作用域，如果返回的对象未还给系统，则可以使用引用返回，则可以使用引用返回，如果已经还给了系统，则必须使用传值返回。
所有上述程序在函数的生命周期结束后栈帧回退，引用所指向的地址不一定是安全可访问的。
综上：引用不要去返回局部变量。

针对这个问题，如果改写成：

#include <iostream>
using namespace std;
int& Add (int a,int b)

    static int c = a + b;
    return c;

int main()

    int& ret = Add(1,2);
    Add(3,4);
    std::cout<<"Add(1,2) = "<<ret<<endl;
    return 0;

那么结果又会发生些许变化（这块伏笔，留着以后复习用）。

1.4 传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，认识传递实参或者返回变量的一份临时拷贝，因此用值作为参数或者返回值类型，效率是非常低下的。而引用不会开辟新的内存空间，所以在效率上是极高的的。

1.5 引用和指针的区别

引用在语法概念上引用就是一个别名，没有独立空间，和其引用的对象共用同一块内存空间。但是引用在底层实现上实际是由空间的，因为引动是按照指针方式来实现的。


引用和指针的不同点：
1.引用在定义时候必须初始化，指针没有要求。
2.引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
3.引用没有NULL引用，但有NULL指针。
4.大小不同，引用的大小是自身引用类型的大小，而指针的大小固定为4个字节（32位平台）
5.引用自加即引用的实体加1，指针自加即指针向后偏移一个类型的大小。
6.有多级指针，但是没有多级引用。
7.访问实体的方式不同，指针需要解引用，引用则是编译器自己处理。
8.引用比指针使用起来相对安全。

二、内联函数

1.什么是内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会在点用内联函数的地方展开，没有函数压栈的开销，内联函数可以提升程序运行的效率。

2.内联函数的特性

1.内联函数是一种以空间换区时间的做法，省去了调用函数额外的开销。所以当代码很长时、由循环或者有递归的函数时，不适合使用内联函数。

2.内联函数对编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环或者递归，编译器优化时候会自动忽略掉内联函数。

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

三、auto关键字(C++11)

在C++11中，标准委员会赋予了auto全新的定义:auto不再是一个存储类型指示符，而是作为一个新的类型指示符指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

using namespace std;
int TestFun()

    return 10;

int main()

    int a = 10;
    auto b = a;
    auto c = b;
    auto d = TestFun();
    return  0;

注意：使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推到auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期间会将auto替换为实际的变量类型。

auto的使用细则

1.auto与指针和引用结合起来使用

2.在同一行定义多个变量

void TestFun()

    auto a = 1,b = 2;
    auto c = 3,d = 4.0;//d = 4.0会出错，因为c和d的表达式类型不同

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

3.auto不能推到的场景

#include <iostream>
using namespace std;
void TestFun(auto a)

void TestFun(auto a)//编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导


void TestAuto()

    int a[] = 1,2,3;
    //auto b[] = 4,5,6;//auto不能直接用来声明数组；
    auto c = a;//此处c的类型为int*