1 引用:

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

#include<iostream>
using namespace std;

int main()
{
	int a = 0;

	// 引用：b是a的别名

	int& b = a;
	int& c = a;
	int& d = b;

	++d;

	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &d << endl;

	return 0;
}

        在上述代码中,我们定义了一个整型变量a=0,然后,这样"int&b=a"定义了一个b,这时就有小伙伴看不懂了?这个"&",不是C语言中的取地址吗?这是什么意思?

        类型& 引用变量名(对象名) = 引用实体,在C++中,"&"被我们的祖师爷赋予了另一种含义"引用"

        引用是给对象起的一个别名，它也是一种复合类型。通过将声明符写成 &d 的形式来定义引用类型，其中 d 是声明的变量名。定义引用时，程序把引用和它的初始值绑定在一起，而不是将初始值拷贝给引用。一旦初始化完成，引用将和它的初始值对象一直绑定在一起。因此引用必须初始化，而且引用不能重新绑定到另一个对象，类型要和绑定的类型一致。引用本身不是独立的数据类型，所以不占用空间，引用的地址就是对象的地址。也就无法定义指向引用的指针，无法声明存储引用类型的数组等.

        在上述代码中,小伙伴们,可以看到b和c都是对a的引用,d是对a的引用,那我们对d进行++操作,会不会改变其他几个呢?

        当然,上面说了,引用就相当于起了个别名,比如:小三是张三的别名,小三吃饭了,那我们猜猜张三吃饭了吗?,肯定也吃了呀.所以引用只是给他换了一个名字,但其实还是本身,所以对d进行++会对其它所有别名进行改变.

        那么引用是用来干嘛的呢?请看下面代码:

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

int main()
{
    int a=10,b=20;

    //Swap(&a,&b);//第一种

    Swap(a,b);//第二种
    
    return 0;
}

        在上述代码中,第一种方法想必是大多数小伙伴常用的指针,那么第二种就是我们今天要学习的"引用"从定义角度和调用角度,二者都有所差距.指针是通过传地址进行改变,而引用是通过给实参取别名,从而进行交换,需要注意的是引用的地址和数据本身的地址是相同的.看起来是不是引用用起来更加方便了?

        同时指针不止能给一些内置类型取别名,还能给指针取别名哦~

int main()
{
	int x = 0;
	int* p1 = &x;
	int*& pr = p1;
	pr = NULL;
    return 0;
}

        在上述代码中,我们用一个指针p1去存储x的地址,用pr去给p1套了一层引用,然后对pr进行置空,这样p1也就置空了.所以这样来看引用还是挺好的

1.1引用的特性:

        1. 引用在定义时必须初始化

void TestRef()
{
   int a = 10;
   // int& ra;   // 该条语句编译时会出错
   int& ra = a;
   int& rra = a;
   printf("%p %p %p\n", &a, &ra, &rra);  
}

        上述代码中如果只是定义一个:"int& ra"而不对其进行初始化的话,编译器会报错,取别名总要有一个主体吧

        2. 一个变量可以有多个引用

1.2 常引用:

int main()
{	
    // 权限的平移
	int x = 0;
	int& y = x;

	// 权限的缩小，可以
	const int& z = x;
	//z++; // 不可以
	y++;//可以

	// 权限的放大
	// m只读
	// n变成我的别名，n的权限是可读可写
	// 权限的放大，不可以
	const int m = 0;
	// int& n = m;

	const int& n = m;

    return 0;
}

        上述代码中,第一处:定义了一个int型的x=0,然后给x取了一个别名y,,都是可读可写的, 这样写是合乎语法的;

        第二处:定义了一个const int的z并且给x取别名了,这样写是相当于权限的缩小,因为x是可读可写的,而z是只能读,所以z的权限被缩小了,完全是可以的,同时要注意,我们不能通过z去进行修改,只能通过y去修改,那么就有小伙伴要问了,y改变了,z变了吗?先给结论,z也会跟着变,为什么呢?因为const只是不能去直接修改它所修饰的变量,但是可以间接的去修改;

        第三处:定义了一个const int 型的m,然后定义了一个int型的n给m进行取别名,可不可以呢?肯定是不行的嘛.因为m是只能读不能写的,而n是可读可写的,这样就权限放大了不合乎语法会报错,只有把n也该成const int型的才可以,相当于权限的平移.

        关于引用的东西远不于此过不了多久就会再次相见~~~

1.3 引用的探讨:

        那我们再探讨一个问题:引用开不开空间呢?

        这个问题我们可以从汇编层次来看:

        从这里我们可以看出,在汇编层次上来看,指针和引用好像是你"亲兄弟"一样,哈哈~是的,它们在汇编层面只是寄存器不同,其他都相同,我们都知道指针是开空间的,所以我们可以得出结论了:

        结论:引用在会汇编层面是和指针一样需要开空间的,但是我们在语法上通常认为引用是不开空间的. 

1.4 引用与指针的对比及优缺点:

1.4.1 引用和指针的对比:

10.内存占用：引用不占内存，而指针占用内存。
11.数组和指针：不能声明引用数组，可以声明指针数组。
12.引用的引用：不能定义引用的引用，而可以定义指针的指针。

1.4.2 引用的优点:

1.性能更好：引用的性能可能会更好，因为指针会导致变量在栈里一定会有地址，可能会引起反复解引用的问题，而引用可以让无需压栈的变量一直在寄存器里，不生成地址。
2.更安全：引用本身是目标变量或对象的别名，对引用的操作本质上就是对目标变量或对象的操作。因此能使用引用时尽量使用引用而非指针。

1.4.3 指针的优点:

1.灵活性高：指针可以指向任意类型的对象，并且可以在运行时动态地改变指向的对象。
2.可以为空：指针可以为空，这在某些情况下是很有用的，例如表示一个不存在的对象或者表示一个结束标志。

        总的来说，引用和指针都有各自的优缺点，在使用时需要根据具体情况进行选择。如果需要高效地传递大型对象或者需要在函数内部修改外部变量的值，引用是一个不错的选择。如果需要灵活地操作对象或者需要处理动态分配的内存，指针可能更合适。

2 内联函数:

2.1 内联函数的概念:

        内联函数是在程序编译时，编译器会将内联函数的代码直接嵌入到调用它的地方，而不是像普通函数那样进行函数调用的一系列操作（如建立栈帧等）。

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

查看方式：

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

2.2 内联函数的特性:

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

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建 议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不 是递归、且频繁调用的函数采用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;
}