C++中的引用的补充丶内联函数丶auto和nullptr的基础用法
一. 引用的补充以及引用和指针的区别
1. 引用可能会造成权限放大
引用造成隐式的权限放大,原因是引用了具有常属性(const)的临时变量。
我们知道在进行类型转换和运算时都会生成临时变量,该临时变量是编译器隐式生成的,不是我们自己显示生成的。
比如在类型转换的时候:
double d = 12.34;
int i = d;
这里内部的过程是这样的:
· 首先编译器会根据d的值和i的类型产生一个i类型的临时变量(我们暂时称它为temp,它是const int类型的,经过d截断生成的);
· 其次该临时变量被赋值给i,代码语句如:int i = temp;
那么当类型转换涉及引用时会如何呢?
double d = 12.34;
int& m = d;
首先,当把这两条代码放进VS2022里的时候,它会报错:
我们回顾上面类型转换时内部的过程:
· 生成了一个const int temp,然后int& m = temp;
这很明显出错了,因为变量引用不能接受常量,否则会造成权限放大;
正确的方式:
double d = 12.34;
const int& m = d;
同样的,在进行运算时:
int x = 0, y = 1;
//int& r2 = x + y; //不行
const int& r2 = x + y; //可行
2. 引用和指针的区别
1. 引用和指针的底层
·语法上,引用是不开辟空间的,而指针是开辟空间的;
·底层上,引用和指针都需要开辟内层空间,引用的底层是一种指针;
我们通过VS2022的反汇编来查看底层中指针和引用机器指令:
int a = 0;
int& b = a;
int* p = &a;
汇编指令:
很明显,指针和引用在底层的机器码中都开辟了内存。
2. 没有NULL引用,但是有NULL指针(相对而言的)
首先先来看一段代码:
//下面代码是否会报错?
int* ptr = NULL;
int& r = *ptr;
这里看似空指针被解引用,然后引用了该值。
但是这里代码是可以正常不报错运行的。
先不解释NULL的解引用,先来说引用为空内容的情况
引用要求引用一块有效内容,根据引用来操作该内容的数据。不同于指针可以指向空,引用为空内容是没有意义的,所以将“没有NULL引用,但是有NULL指针”。
这里我们解释一下上面NULL的解引用。
首先我们知道,NULL值是不能被解引用的。这里却可以正常运行,那么它到底有没有被解引用呢?
我们转到反汇编看一下:
注意:底层这里并没有真正地将指针进行解引用,只是单纯地传递值。
3. 引用和指针不同点的总结
- 1.引用概念上定义一个变量的别名,指针存储一个变量的地址
- 2.引用在定义时必须初始化,而指针没有要求
- 3.引用在初始化引用一个实体后,就不能在引用其他实体,而指针可以在任何时候指向任何一个同类型实体
- 4.没有NULL引用,但有NULL指针
- 5.在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位下占4个字节)
- 6.引用自加即引用的实体增加1,指针相加即向后偏移一个类型的大小
- 7.有多级指针,但没有多级引用
- 8.访问实体的方式不同,指针需要显示解引用,引用编译器自己处理
- 9.引用比指针使用起来相对更安全
二. 内联函数
1.内联函数出现的原因
在内联函数未出现前,C语言使用函数替换的是宏函数。
宏函数在编写时极易出现问题,比如我们写一个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))
#define ADD(a, b) ((a) + (b))
1.内层括号确保表达式被传递的优先级
2.外层括号确保后面是一个整体
3.不加分号是因为宏函数的本质是替换 ,加了分号相当于被替换中也含有分号
#define ADD(a, b) ((a) + (b))
#include <iostream>
using namespace std;
int main()
{
int ret = ADD(1, 2);
cout << ADD(1, 2) << endl; // 3
int x = 1, y = 2;
ADD(x & y, x | y);
return 0;
}
如果内部括号没有的话,那么执行:
ADD(x & y, x | y);
这条语句时就会出现问题。
因为&和|的优先级都比+低,那么表达式就会被替换未 (x & y + x | y),这时会先算中间的x+y,而这不是我们想要的结果。
从上面可以看出来,宏函数的编写诸多不便,而且极易出错。
于是在C++中出现了新的替换函数:内联函数
2. 内联函数的特性
1. 本质是一种空间换时间的做法
inline是一种以空间换时间的做法,如果编译器将函数当成内联函数处理,在编译阶段,会用函数体替换函数调用;
- 缺陷:可能会使得目标文件变大;
- 优势:少了调用开销,提高运行效率。
普通的函数在调用是会建立栈帧,根据函数地址调用函数;而内联函数是在调用处直接展开,没有函数调用建立栈帧的开销,也不会出现宏函数类似的问题。
2. inline对于编译器来说只是一个建议
inline对于编译器而言只是一个建议,不同编译器关于inline实现机制可能不同,一般建议:将函数规模较小(即函数不是很长,具体没有准确的说法,取决于编译器内部实现)丶不是递归丶而且频繁调用的函数采用inline修饰,否则编译器会忽略inline特性。
在《C++prime》第五版关于inline的建议:
· 内联说明只是向编译器发出的一个请求,编译器可以选择忽略这个请求。
利用反汇编查看底层是如何展开的:
#include <iostream>
using namespace std;
inline int Add(int a, int b)
{
int ret = a + b;
return a + b;
}
int main()
{
int c = Add(1, 2);
cout << c << endl;
return 0;
}
int c = Add(1, 2); 处的汇编指令:
可以看出,这里并没有call(函数调用),而是直接展开,执行函数体内的代码对应的汇编指令。
3.内联函数不建议声明和定义分离
inline不建议声明和定义分离,分离会导致链接错误。因为inline在调用处被展开,而展开处没有函数实体定义,更不会有函数地址,链接就会找不到函数定义而报错。
内联函数在编写时不要声明和定义分离,内联函数直接在.h文件定义就可以。
4. 内联和宏的总结
C++通常用两种技术替代宏:
- 1.常量定义,换用const enum
- 2.短小函数定义,换用内联函数
宏的优缺点:
优点:
- 1.增强代码的复用性;
- 2.提高性能
缺点:- 1.不方便调试宏。(因为预编译阶段进行了替换)
- 2.导致代码可读性差,可维护性差,容易误用
- 3.没有类型安全的检查
三. auto关键字
auto 用于自动类型推导
- 格式:auto 变量名 = 某标识符
- 形如:auto i = 2;(auto将自动推导为int类型)
注意:在使用auto应用于自动类型推导时,必须要在定义时初始化。
示例代码如下:
#include <iostream>
using namespace std;
typedef char* pstring;
//auto 作为自动类型推导
int main()
{
int a = 0;
//auto b; //编译不通过 使用auto定义变量时必须要对其进行初始化
auto c = a; //编译通过
//const int i; //编译不通过 i为常属性 需要初始化
const pstring* p2;
//const pstring p1; //相当于char* const p1 此时编译不通过
//因为p1为常属性 需要初始化
return 0;
}
1. 使用auto的注意事项
1.当在同一行声明多个变量时,这些变量必须是相同的类型,否则编译器会报错
因为编译器实际只对第一个类型进行推导,然后用推导出来的类型定义其他变量。
代码示例:
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; //d = 4.0会编译前报错
//因为c和d的初始化类型不同
//编译器只对第一个类型进行推导 推出int 而int不是d的类型
}
2. auto不能当作形参类型
void TestAuto(auto a)//此处代码编译前报错
//因为编译器无法对a的实际类型进行推导
{
//do nothing
}
3. auto不能直接用来声明数组
void TestAuto()
{
int a[] = { 1,2,3 };
auto b[] = { 4, 5, 6 }; //编译前出错
}
2. auto推导的情况
直接上代码:
//auto的推导情况
#include <iostream>
using namespace std;
int main()
{
int x = 10;
//auto可传普通也可传指针
auto a1 = x;
auto a2 = &x;
//auto* 指定必须时指针
auto* b = &x;
//引用
auto& c = x;
return 0;
}
3. C++11中的范围for
//可以使用auto自动推导数组类型
#include <iostream>
using namespace std;
int main()
{
int array[10] = { 1,2,3,4,5,6,7,8,9,10 };
//自动取出数组array中的数据依此赋值给e
//自动进行迭代,自动判断结束
for (auto e : array)
{
cout << e << " ";
}
//指明类型也可以 但是需要跟array中的元素的类型对应
for (int e : array)
{
cout << e << " ";
}
cout << endl;
return 0;
}
//不支持下面这种写法
void Test(int array[])
{
for (auto& e : array)
cout << e << endl;
}
4. typeid可获取数据的类型
格式:typeid(数据).name() 获得一个 (const char)的字符串*
代码示例如下:
#include <iostream>
using namespace std;
int TestAuto()
{
return 10;
}
int main()
{
int a = 10;
auto b = a;
auto c = 'a';
auto d = TestAuto();
cout << typeid(b).name() << endl; //int
cout << typeid(c).name() << endl; //char
cout << typeid(d).name() << endl; //int
return 0;
}
四 . NULL和nullptr
1. NULL的缺陷
NULL实际上是一个宏。
在传统的C头文件stdef.h中,它是大致这样被定义的:
#define NULL 0
#define NULL ((void *)0)
但是这样是有缺陷的,比如运行如下代码时:
#include <iostream>
using namespace std;
void f(int)
{
cout << "f(int)" << endl;
}
void f(int*)
{
cout << "f(int*)" << endl;
}
int main()
{
//表面上看 f(0)应匹配f(int);f(NULL)应匹配f(int*)
f(0); //实际上0和NULL都会匹配到f(int) 这是因为NULL是由宏定义的0
f(NULL);
f((int*)NULL);
//而C++的新关键字nullptr不会有这样的问题
f(nullptr); //调用f(int*)
return 0;//调用f(int*)
}
注意:宏定义的替换是在预处理阶段由预处理器来进行的。
2. 关键字nullptr
为了解决NULL这种问题 C++引入了关键字nullptr:
- 1.在使用nullptr表示指针空值时,不需要包含头文件,因为nullptr是C++作为新关键字引入的
- 2.在C++11中,sizeof(nullptr)于sizeof((void*)0)所占的字节数相同
- 3.为了提高代码的健壮性,在后续表示指针空值时建议最好使用nullptr
本博客仅供个人参考,如有错误请多多包含。
Aruinsches-C++日志-4/2/2024