c++入门——引用和内联函数
引用和内联函数
- 引用
- 1 引用概念和使用
- 2 使用场景
- 3 常引用
- 4 传值、传引用效率分析
- 5 引用和指针对比
- 内联函数
- 1 内联函数的特性
- 2 内联函数和宏的对比
引用
1 引用概念和使用
引用不是新定义一个变量，而是给已存在变量取别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
java抄c++的引用后，连指针都抄没了。因为java基于这3个原因把显指针的概念隐藏：
- 安全性考虑。即减少越界访问。
- 简化编程模型。因为指针学习成本相对其他知识点来说比较高，还很容易造成逻辑混乱。
- 垃圾回收机制。即通过指针在堆区申请的空间需要用户来回收，java会自动管理内存。
引用的出现还是因为指针太难用。
格式：
类型& 引用变量名(对象名) = 引用实体;
例子:
#include<iostream>
using namespace std;
int main() {
int b = 0;
int& a = b;//a相当于b的别名
cout << b << endl;
a = 3;
cout << b << endl;//更改a，b会发生什么？
cout << &a << endl << &b << endl;//查看他们的地址
return 0;
}
运行结果：
&这个符号的含义有3个：
- 位与（例如：
a=a&b;）- 取地址(&var)（例如：
int a=1;int b=&a）- 引用(例如：
int& a = b;)取地址还衍生出一种说法：输出型参数，即希望函数对实参内容直接进行修改的形参。
例如：
#include<iostream> using namespace std; void f(int* a){ a=3; } int main(){ int a=1; f(&a); cout<<a<<endl;//通过函数f修改a的值 return 0; }适用场景：如函数形参用引用，形参是实参的别名，可省去很多底层实现。
注意：引用类型必须和引用实体是同种类型的
引用特性：
-
引用在定义时必须初始化，形如
int& a;这种不允许。 -
一个变量可以有多个引用（给别名取别名）
-
引用一旦引用一个实体，再不能引用其他实体
2 使用场景
- 做参数
引用做形参的好处：当上万字节的对象不方便拷贝时用引用做形参可节省开支。
void Swap(int& left, int& right){
int temp = left;
left = right;
right = temp;
}
- 做返回值
int& f(){
return 0;
}
注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用
引用返回，如果已经还给系统了，则必须使用传值返回。
例子1：传值返回
#include<iostream>
using namespace std;
int count1() {
int n = 0;
n++;
;
return n;
}
int& count2() {
int n = 0;
n++;
;
return n;
}
int main() {
int a = count1();//将n的临时变量的值赋值给a
int& ret = count2();
cout << a << ' ' << hex << ret;//按十六进制数的格式输出ret
return 0;
}
count2是传引用返回，相当于是返回局部变量n的别名（引用），但其实n在count2个函数中生成后，随着count2的结束运行而销毁。因此ret访问n的时间并不确定，也就造成ret可能是1，也可能是随机值（系统初始化栈时用的值，vs环境是0xcccccccc)，这个取决于编译器。
比如，vs2019的msvc（cl.ext）：
又比如，Dev-cpp的g++.exe：
例子2：
#include<iostream>
using namespace std;
int& Add(int a, int b) {
//int d[1000]={0};
int c = a + b;
return c;
}
int main() {
int& ret = Add(1, 2);
cout << ret << endl;
cout << ret << endl;
//cout << ret << endl;//这就有了一个现象，只要ret表示的内存不被征用，一直是3
//cout << ret << endl;
cout << ret << " is Add(1, 2)" << endl;//字符串征用了ret代表的空间后，那片空间被回收
cout << hex << ret << endl;
Add(3, 4);
cout << ret << endl;
cout << "Add(1, 2) is :" << ret << endl;//虽然是7，但不是所有编译器都会输出7
cout << "Add(1, 2) is :" << ret << endl;
return 0;
}
输出结果（环境为vs2019）：
ret实际代表的是已经被系统回收的整型变量c的空间，这样访问（int& ret = Add(1, 2);）无异于越界访问。
在vs中的运行情况进行分析：
引用变量ret初始化为引用函数Add的返回值c，代码中先调用两次ret，得到的是Add(1, 2)的返回值3。因为还未调用Add函数调用过的空间，所以输出的还是3。
当向cout输出一个字符串形参时，ret代表的空间被调用，用于存储字符串。之后字符串被系统回收，空间包括ret代表的空间被初始化，所以第16行输出的是初始化后的值。
再调用一次Add(3, 4)，ret也就是局部变量c的值变成7。不是所有编译器都会输出7，这个取决于编译器是怎么讲c++源码翻译成机器码的。
再次上传字符串作为形参，则又会被初始化。
因此在n之前先定义一个占字节数比较大的东西（如1000个元素的数组），此时Add的占用空间便影响不到n的占。
这里在定义c之后引入一个数组时，因为数组的空间来不及回收，使得ret的值无论怎么输出都是一样的（仅限msvc，这里不再给出g++的测试结果）。
#include<iostream>
using namespace std;
int& Add(int a, int b) {
int c = a + b;
int d[1000] = { 0 };
return c;
}
int main() {
int& ret = Add(1, 2);
cout << ret << endl;
cout << ret << endl;
//for (int i = 1; i <= 1000; i++)
// cout << ret << "abc" << endl;
cout << ret << " is Add(1, 2)" << endl;
cout << hex << ret << endl;
Add(3, 4);
cout << ret << endl;
cout << "Add(1, 2) is :" << ret << endl;
cout << "Add(1, 2) is :" << ret << endl;
return 0;
}
当调换c和数组的定义顺序时，因为c所在的空间频繁的被引用和释放，输出的值也是各有差异。
#include<iostream>
using namespace std;
int& Add(int a, int b) {
int d[1000] = { 0 };
int c = a + b;
return c;
}
int main() {
int& ret = Add(1, 2);
cout << ret << endl;
cout << ret << endl;
cout << ret << endl;
//for (int i = 1; i <= 1000; i++)
// cout << ret << "abc" << endl;
cout << ret << " is Add(1, 2)" << endl;
cout << hex << ret << endl;
Add(3, 4);
cout << ret << endl;
cout << "Add(1, 2) is :" << ret << endl;
cout << "Add(1, 2) is :" << ret << endl;
return 0;
}
输出结果（同样仅限msvc）：
注意：这里做返回值的测试都是未定义行为，频繁的访问系统回收的空间可能引发大范围的bug，所以不要轻易尝试。
但这个情景也不是不能使用而是想办法让这个引用变量代表的空间不被系统回收。例如，传引用返回的返回值是一个静态局部变量：
#include<iostream>
using namespace std;
int& f() {
static int times = 0;
times++;
return times;
}
int main() {
int& num = f();
for (int i = 0; i < 20; i++) {
num++;
cout << f() << ' ';
cout << num << endl;
}
return 0;
}
3 常引用
例子：
int f() {
int a = 0;
return a;
}
int main() {
//int& ret = f();//报错：非常量的引用的初始值必须为左值
const int& ret = f();
return 0;
}
f()会返回一个临时变量（或对象），在main函数中需要用一个常变量引用来给这个临时变量取别名。
用const修饰后，临时变量的生命周期被延长，直到不再访问ret（即ret出了作用域，编译器会自行处理，且这个临时变量也只能通过ret访问）。
例子2：
void TestConstRef() {
const int a = 10;
//int& ra = a; // 该语句编译时会出错，a为常量
const int& ra = a;
// int& b = 10; // 该语句编译时会出错，b为常量
const int& b = 10;
double d = 12.34;
//int& rd = d; // 该语句编译时会出错，类型不同
const int& rd = d;
}
const int a = 10;到const int& ra = a;是权限平移。两个都是常量不可修改。
const int& b = 10;到int& b = 10;是权限放大（原来不可被修改，但是这样一引用造成的结果是空间内的数据可修改）。因为b作为一个int类型的引用，它是常量10的别名，将可修改的引用定义成不可修改的常量，是权限放大。int& b = 10;是无法通过编译的。
double d = 12.34;到const int& rd = d;是权限缩小。可以通过编译。
例子3：
void f2() {
int i = 0;
//double& ret = i;//报错
const double& ret = i;//可以，权限平移。
}
从int i = 0到double& ret = i;会报错：无法从int转换为double&。分析：i是临时变量（猜测是用的常量0进行初始化），有常属性，编译器会阻止。
而从int i = 0到const double& ret = i;可以。虽然看似i是变量，实际ret是0的别名。
例子4：
void f3() {
int a = 0;
int b = a;//用变量初始化，b不具有常属性
int& c = b;//可以
//double& d = b;//不可以，无法用int初始化double&
}
例子4相当于权限平移。也印证了引例3的猜想（例子2的i用常量0进行初始化）。
所以有结论：权限可以平移、缩小，但不可放大，常属性变为正常变量属性就是权限放大。给变量取别名时不可以放大别名的权限。
4 传值、传引用效率分析
以值作为参数或者返回值类型，在传参和返回期间，函数会传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率很低，尤其是当参数或者返回值类型非常大时（比如包含大量元素的数组的结构体），效率就更低。
看个例子就知道了：
#include <ctime>
#include<iostream>
using namespace std;
struct A {
int a[10000];
};
A a;
// 值返回
A TestFunc1() {
return a;
}
// 引用返回
A& TestFunc2() {
return a;
}
int main() {
// 以值作为函数的返回值类型
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;
return 0;
}
clock函数可以返回程序运行到当前函数时的用时，但精度并不是很高。
TestFunc1返回一个全局（静态）对象，出了作用域a还在。
TestFunc2相比TestFunc1使用了引用返回，提高了效率。
所以这个例子得出的结果：
结论：传值和指针在作为传参以及返回值类型上效率相差很大。
堆区上的动态申请也可用引用返回。
举个例子。保时捷属于大众的一个品牌，但保时捷买的人很多，引用是保时捷，指针是大众，这样的关系不完全一样。但引用不完全等价于指针，尽管他们的内核是一样的，下文会有介绍。
传引用传参（函数形参为引用）的作用：提高效率和输出型参数。
传引用返回（出了函数作用域对象还在可以用）：提高效率和修改返回对象。
5 引用和指针对比
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的（也就是说存在野引用的不官方概念）。
通过vs2019自带的反汇编功能可以看出来指针和引用其实都在底层实现有空间（因为汇编指令时一样的）：
甚至做同样的操作，汇编代码也不会变：
这个例子展示部分引用和指针的不同：
#include<iostream>
using namespace std;
int main() {
int a = 1;
int& b = a;
int c = 2;
int d[10] = { 0,1,2,3,4,5,6,7,8,9 };
int* e = d;
cout << sizeof(a) << ' ' << sizeof(e) << endl;
cout << (++b) << ' ' << *(++e) << endl;
return 0;
}
这里简单总结引用和指针的不同点:
-
引用概念上定义一个变量的别名，指针存储一个变量地址。
-
引用在定义时必须初始化，指针没有要求。
-
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
-
没有空引用（即引用不存在NULL的概念），但有空指针（
NULL和nullptr）。 -
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)。
-
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
-
有多级指针，但是没有多级引用。
-
访问实体方式不同，指针需要显式解引用，引用编译器自己处理。
-
引用比指针使用起来相对更安全。
内联函数
以inline关键字修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
1 内联函数的特性
-
inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用内联函数的函数体替换函数调用，
缺陷：可能会使目标文件变大，
优势：少了调用开销，提高程序运行效率。 -
inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小（即函数不是很长，具体没有准确的说法，取决于编译器内部实现）、不是递归、且频繁调用的函数采用
inline修饰，否则编译器会忽略inline特性。下图为
《C++prime》第五版关于inline的建议：
-
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
2 内联函数和宏的对比
宏是c语言的概念，即用#define指令替换部分符号，用于达到减小编辑成本的目的。
宏的优缺点？
优点：
1.增强代码的复用性。（同一个代码片段在编写阶段用更简短的宏代替，增加代码的编写效率）
2.提高性能。
缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查 。
C++有哪些技术替代宏？
-
常量定义。即换用
const、enum。 -
短小函数定义。换用内联函数。
类似的，inline替换宏函数，const替换宏常量，enum也用于替换宏常量（在cpp）。