Hi！很高兴见到你~
目录
7、引用
7.3 引用的使用（实例）
7.4 const引用
【第一分点】
【第二分点1】
【第二分点2】
7.5 指针和引用的关系（面试点）
8、inline
9、nullptr
Relaxing Time！
——————————《Go Solo》——————————
正文开始——
7、引用
7.3 引用的使用（实例）
//引用作参数，改变引用对象的同时改变被引用对象
#include<iostream>
#include<assert.h>
using namespace std;
//这里rx，ry就相当于x和y的别名，不需要再传地址了
void Swap(int& rx, int& ry)
{
int tmp = rx;
rx = ry;
ry = tmp;
}
int main()
{
int x = 0, y = 1;
cout << x << " " << y << endl;
Swap(x, y);
cout << x << " " << y << endl;
return 0;
}
//引用作参数，传值传参时要拷贝实参给形参，下面使用引用会减少拷贝提高效率
struct A
{
int arr[1000]={0};
}
void Func(A& aa)
{
//...
}
int main()
{
Func(aa1);
return 0;
}
//不用再把实参的4000个字节传给实参，这样就提高了效率，虽然用指针也行但引用更方便//传引用返回实例，与指针相较
#include<iostream>
#include<assert.h>
using namespace std;
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void STInit(ST& rs, int n = 4)
{
rs.a = (STDataType*)malloc(n * sizeof(STDataType));
rs.top = 0;
rs.capacity = n;
}
// 栈顶
void STPush(ST& rs, STDataType x)
{
// 满了， 扩容
if (rs.top == rs.capacity)
{
printf("扩容\n");
int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
rs.a = tmp;
rs.capacity = newcapacity;
}
rs.a[rs.top] = x;
rs.top++;
}
//引用
int& STTop(ST& rs)
{
assert(rs.top > 0);
return rs.a[rs.top-1];
}
//指针
int* STTop(ST& rs)
{
assert(rs.top > 0);
return &(rs.a[rs.top - 1]);
}
int main()
{
// 调⽤全局的
ST st1;
STInit(st1);
STPush(st1, 1);
STPush(st1, 2);
cout << STTop(st1) << endl;
//修改栈顶数据
//引用
STTop(st1) += 10;
//指针
*(STTop(st1)) += 100;
//相比之下，引用使用更方便
cout << STTop(st1) << endl;
return 0;
}
【细节详解】
#include<iostream>
using namespace std;
//不是所有情况都可以用传引用返回，举例
//Func函数用传引用返回，但是出了Func函数ret这个局部变量就销毁了，如果继续引用，就会越界
int& Func()
{
int ret = 20;
//...
return ret;
}
int main()
{
//此处返回的是ret的别名，但是ret已经被销毁了，越界了
Func() += 10;
//越界不一定会报错
int arr[10];
//越界读（打印等不修改）不报错
cout << arr[10] << endl;
cout << arr[11] << endl;
cout << arr[12] << endl;
//越界写(修改)不一定报错，一般是抽查，在数组后面设置两个值，若值被改变，说明越界
arr[10] = 100;
return 0;
}7.4 const引用
- 可以引用一个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。
- 需要注意的是类似 int& rb=a*3；double d=12.34；int& rd=d；这样的一些场景下a*3的结果保存在临时对象中，int& rd=d也是类似，在类型转换中会产生临时对象存储中间值，也就是说，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用常引用才可以。
- 所谓临时对象就是编译器需要一个空间暂存表达式的求值结果时创建的一个未命名的对象，C++中把这个未命名对象叫做临时对象。
【第一分点】
//可以引用一个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。
int main()
{
const int a = 10;
//编译报错：error C2440：“初始化”: 无法从“const int”转换为“int &”
//这里的引用是对a权限的放大，const修饰后a只能读不能写（修改）
int& ra = a;
//针对上面的问题应该这样改，用const引用
const int& ra = a;
//error C3892 : “ra”: 不能给常量赋值，此处ra只许读不许写
ra++;
//这里的引用是对b访问权限的缩小，//const也可以引用普通对象
int b=100;
const int& rb=b;
//编译报错：error C3892：“rb”：不能给常量赋值，此处rb和b指向的是同一块空间，rb的权限缩小不影响b
return 0;
}见下图详解：
【第二分点1】
int main()
{
//需要注意的是类似 int& rb=a*3；double d=12.34；int& rd=d；
//这样的一些场景下a*3的结果保存在临时对象中，int& rd=d也是类似，
//在类型转换中会产生临时对象存储中间值，也就是说，rb和rd引用的都是临时对象，
//而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用常引用才可以。
int a = 10;
//int& rb = a * 3;
const int& ra = a * 3;
/*double d = 13.14;
int rd = d;*/
double d = 13.14;
int& rd = d;
//这里划红线并非是int类型引用double类型的问题，而是d先存储在临时变量里面，
//所以rb引用的是一个临时变量，这个临时变量具有常性，就像被const修饰一样，
//这里就触发了权限的放大
const int& rd = d;
return 0;
} 见下图详解：
【第二分点2】
7.5 指针和引用的关系（面试点）
C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能具有重叠性。但是各有自己的特点，互相不可替代。
- 语法概念上引用是一个变量的取别名不开空间，指针是存储一个变量的地址，要开空间。
- 引用在定义时必须初始化，指针建议初始化，但语法上不是必须的。
- 引用在初始化时引用一个对象后，就不能在引用其他对象，而指针可以不断地改变指向对象。
- 引用可以直接访问引用对象，指针需要解引用才能才能访问指向对象。
- sizeof 中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占的字节个数（32位平台下占4个字节，64位平台下占8个字节）。
- 指针很容易出现空指针和野指针的情况，引用很少出现，引用使用起来相对安全一些。
//sizeof 中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占的字节个数（32位平台下占4个字节，64位平台下占8个字节）。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
int main()
{
int a = 0;
int& ra = a;
int* pta = &a;
cout << sizeof(ra) << endl;
cout << sizeof(pta) << endl;
return 0;
}//指针很容易出现空指针和野指针的情况，引用很少出现，引用使用起来相对安全一些。
//这里ret就是野引用
#include<iostream>
using namespace std;
//不是所有情况都可以用传引用返回，举例见下
//Func函数用传引用返回，但是出了Func函数ret这个局部变量就销毁了，如果继续引用，就会越界
int& Func()
{
int ret = 20;
//...
return ret;
}
int main()
{
//此处返回的是ret的别名，但是ret已经被销毁了，越界了
Func() += 10;
//越界不一定会报错
int arr[10];
//越界读（打印等不修改）不报错
cout << arr[10] << endl;
cout << arr[11] << endl;
cout << arr[12] << endl;
//越界写(修改)不一定报错，一般是抽查，在数组后面设置两个值，若值被改变，说明越界
arr[10] = 100;
return 0;
}8、inline
- 用 inline 修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧，提高效率。
- inline对于编译器而言只是一个建议，也就是说，加了inline编译器也可以选择在调用的地方不展开，不同的编译器就关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适用于频繁地调用短小的函数，对于递归函数，代码相对多一些的函数，加上inline也会被编译器忽略。
- C语言实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错，切不方便调试，C++设计inline目的就是为了替代C的宏函数。
- VS编译器debug版本下面默认是不展开inline的，这样方便调试，debug版本想展开需要设置以下两个地方。
- inline不建议声明和定义分离到两个文件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现错误。
inline对于相对多一些的函数，为什么加上inline也会被编译器忽略呢？
假如Add函数有100行指令，有10000个地方调用
Add展开，要10000*100行指令；
Add不展开，建立栈帧，但是只要10000*1+100行指令。
可以看作是编译器的一个防御策略。
#include<iostream>
using namespace std;
// 实现⼀个ADD宏函数的常⻅问题
//#define ADD(int a, int b) return a + b;
//#define ADD(a, b) a + b;
//#define ADD(a, b) (a + b)
// 正确的宏实现
#define ADD(a, b) ((a) + (b))
// 为什么不能加分号?
// 为什么要加外⾯的括号?
// 为什么要加⾥⾯的括号?
int main()
{
//宏的本质相当于替换
// 为什么不能加分号?
int ret = ADD(1, 2);
cout << ADD(1, 2) << endl;
//如果加分号，就变成了下面这样，报错
cout << ADD(1, 2); << endl;
// 为什么要加外⾯的括号?
cout << ADD(1, 2)*5 << endl;
cout << (a) + (b)*5 << endl;
// 为什么要加⾥⾯的括号?
int x = 1, y = 2;
ADD(x & y, x | y); // -> (x&y+x|y)
//这样就变成了y+x先运算，+的优先级更高，加减乘除的优先级都是偏高的，位运算的优先级都是偏低的
return 0;
}#include<iostream>
using namespace std;
//没有宏函数的坑，也不用建立栈帧，提效
inline int Add(int x, int y)
{
int ret = x + y;
ret += 1;
ret += 1;
ret += 1;
return ret;
}
int main()
{
// 可以通过汇编观察程序是否展开
// 有call Add语句就是没有展开，没有就是展开了，但Add函数较长，就不展开了，inline对编译器是一个
//建议，最终决定权在编译器
int ret = Add(1, 2);
cout << Add(1, 2) * 5 << endl;
return 0;
}9、nullptr
NULL实际是一个宏，在传统的C头文件（stddef.h）中，可以看见如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif- C++中NULL可能被定义为字面常量0，或者C中被定义为无类型指针（void*）的常量。不论采用何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，本想通过f（NULL）调用指针版本的f（int*）函数，但是由于NULL被定义为0，调用了f（int*），因此与程序的初衷相悖。f（void*）NULL；调用会报错。
- C++11中引入nulltptr，nullptr是一个特殊的关键字，nullptr是一种特殊类型的字面量，它可以转换成任意其他类型的指针类型。使用nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式的转换为指针类型，而不能被转换成整数类型。
#include<iostream>
using namespace std;
void f(int x)
{
cout << "f(int x)" << endl;
}
void f(int* ptr)
{
cout << "f(int* ptr)" << endl;
}
int main()
{
f(0);
// 本想通过f(NULL)调⽤指针版本的f(int*)函数，但是由于NULL被定义成0，调⽤了f(intx)，因此与程序
//的初衷相悖。
f(NULL);
f((int*)NULL);
// 编译报错：error C2665: “f”: 2 个重载中没有⼀个可以转换所有参数类型
// f((void*)NULL);
f(nullptr);
return 0;
}完——
Relaxing Time！
——————————《Go Solo》——————————
Go Solo_Zwette、Tom Rosenthal_高音质在线试听_Go Solo歌词|歌曲下载_酷狗音乐
至此结束！
我是云边有个稻草人
期待与你的下一次相遇——
![C++ char*和char[] 可能指向的内存区域详解（附实验）](https://i-blog.csdnimg.cn/direct/56c11ea0cb5945d78990329f76be1dbd.png)
