引用的概念和定义

在语法上引用是给一个变量取别名，和这个变量共用同一块空间，并不会给引用开一块空间。

取别名就是一块空间有多个名字

类型& 引用别名 = 引用对象

int main()
{
	int a = 2;
	int& b = a;
	int& c = a;
	int& d = b;
	//对d取别名，d是b的别名，b是a的别名，d就是a的别名
	b++;

	cout << a << " " << endl;
	cout << b << " " << endl;
	cout << c << " " << endl;
	cout << d << " " << endl;
	// 都是3
    //这就说明了b、c、d都是a的别名，和a共用同一块空间
    
	return 0;
}

引用的特性

1.引用在定义时必须初始化（必须说明是谁的引用）
不说明是谁的引用会报错
2.一个变量可以有多个引用（给别名取别名）
3.引用一旦引用一个实体，再不能引用其他实体
（引用不能改变指向）
1,2点比较简单，现在对第三点说明一下

链表要改变指向要用二级指针

int main()
{
	int a = 2;

	int& b = a;

	int d = 20;
	
	b = d;
	//这里是赋值不是引用，b不是d的引用
	d++;
	//对d++，a和b并不改变，也说明了b不是d的引用
	//b本来是a的引用，并不能改变成b是d的引用，说明引用不能改变指向
	//后面也会介绍
	
	return 0;
}

引用的使用

1.引用做传参和做返回值

• 提高效率
• 减少拷贝
• 引用对象改变同时被引用对象改变

比如传值调用，传一个值x,函数中a拿到的是x的一份临时拷贝，而如果用引用就减少了拷贝，提高了效率，因为a是x的别名，就是给本身取了另一个名字

引用对象改变同时被引用对象改变
x++,a也++，你的别名改变了，你本身也会改变

void f1(int& x)
{
 x++;
}

int main()
{
  int a = 0;
  f1(a);

  return 0;
}

引用做返回值
1.int 做返回时返回一个数值，不是直接返回而是会生成一份临时变量再返回，临时变量具有常性，不能被改变

2.int& 做返回时生成一个它的引用，再返回它的引用，数组在堆上出函数不销毁，返回数组中的引用，出函数，改变数组中的某个值

const引用

注意：权限放大和缩小只存在指针和引用里面
权限不能放大，可以缩小

1.权限放大

const int a = 10;//只读不能写（修改）
int& ra = a;//可以读可以写，权限放大
//正确写法
const int& ra = a;

const int a = 10;//可读不可写
int& ra = a;
//权限放大
const int& ra = a;

const int a = 10;
int rd = a;
//a只读，a的值拷贝进rd中，a一个空间，rd又是一个空间
//rd可读可写,这只是一个拷贝，不是权限放大，
//权限放大只存在指针和引用中

2.权限缩小

int b = 20;
const int& rb = b;

b++;//21，本身权限不缩小
rb++;//不能够改变，只是它的引用权限缩小了

3. 产生临时对象
临时对象具有常性

• 表达式运算

int a = 10;
const int& rc = 30;
const int& rd = (a+30);

• 函数传值返回

int fun(int& a)
{
   a++;
   return a;
}

• 类型的隐式转换

double d = 2.32;
int i = d;
const int& ri = d;
//double类型转化为int时，会把整型部分放入临时变量中

指针和引用的关系

指针和引用互相不可替代

• 引用取别名不开空间，指针存一个变量的地址要开空间
• 引用必须初始化，指针建议初始化，但是语法上不是必须的，指针可以先定义，后面把一个变量的地址放入指针中
• 引用只能引用一个对象，而不能再引用其他对象，而指针可以不断改变指向
• 引用可以直接访问指向对象，指针必须解引用才能访问指向对象
• 引用和指针的sizeof含义不同，引用sizeof是引用类型的大小，指针32位平台下是4个byte,64位平台下是8个byte
• 引用不容易出现空引用和野引用，指针容易出现空指针和野指针

野引用

int& func()
{
   int a = 0;
   return a;
   //会产生一个别名，返回它的一个别名
   //出函数别名销毁，它的引用销毁
   //再去找它的引用，就是野引用
}

空引用

int* ptr = NULL:
int& rb = *ptr;
//空引用可以通过编译
rb++;
return 0;
//rb++是对空引用的使用
//对空引用的使用，不会返回0，会返回一个负数，异常返回

表面上是对ptr这个空指针解引用，实际上它的汇编代码并不解引用，而是把ptr的地址放入一个寄存器中，再把寄存器中的地址给rb这个别名，引用的底层是指针

引用的实际作用

以前交换两个值用传地址的方式 swap(&a,&b);
现在有了引用，可以用swap(a,b);
在主函数中调用函数不用取地址，传参过去的函数定义用引用接收void swap(int& x,int& y),可以不用指针接收，而且不用解引用那么麻烦

但是链表中的二级指针LTNode*& != LTNode&&,指针不能用引用替代掉，C++的引用不能替代指针，因为引用不能改变指针的指向，链表要改变指针的指向用二级指针，LTNode*& == LTNode** ,引用的底层可以理解为指针

引用的实际作用体现在传参里面
使用函数模板，T可以是任意类型

template<class T>
void func(const T& val)
{
  //...
  const 对象
  常量->具有常性
  临时变量->具有常性
  普通变量->可以权限缩小
}

inline

用inline修饰的函数叫内联函数，C++在调用的地方直接展开内联函数，就不需要建立栈桢了，这样可以提高效率

• C++的inline为了替代C语言的宏函数而设计出来的，宏函数也不建立栈桢，#define 定义的宏函数是一个宏，直接展开
• 你的代码过大，不会帮你展开，比如递归层次太深，会造成可执行程序变大，内存占用变大，编译器会帮你展开代码短小重复的代码，比如swap交换两个数的值的代码
• inline不建议声明和定义分离到两个文件，分离会导致链接错误，因为inline展开，函数定义文件的地址会消失，导致找不到函数定义，只有声明，所以定义和声明应该在同一个文件，在调用的地方展开会直接执行
• vs下默认不展开内联函数，找到项目属性做以下设置
  
  

//内联函数
inline int Add(int x,int y)
{
  int ret = x + y;
  return ret;
}

未展开内联函数
call跳转地址，建立栈桢

展开内联函数
不跳转，直接在调用的地方展开函数逻辑

nullptr

nullptr是关键字
nullptr是C++中的空指针，专门用来表示空指针，nullptr只能隐式类型的转换成其他类型的指针形式，不能转化成其他类型，比如int

C语言中的 （（void*）0）可以隐式类型转为int和int或其他类型，C++用这套在传参中也是不确定的，会传整型又会传指针
C++的NULL是0，传参中，一个函数的参数是int,另一个函数的参数是int,那么会执行第一个函数，C++中的NULL指针类型又是整型0,这样比较模糊，所以空指针用nullptr表示，nullptr也是0，但它只有指针形式

void func(int* a)
{}//1
void func(int a)
{}//2
int main()
{
  func(0);//2
  func(NULL);//2
  func((void*)0);//会隐式类型转化，int或int*，不确定走哪个
  //这样说C++走不了空指针了，所以定义一个nullptr表式空指针
  return 0;
}

#define NULL 0  C++
#define NULL ((void*)0) C