C++：详解按引用传递、内联函数，auto用法、指针空值

最新推荐文章于 2024-04-05 00:37:31 发布

It‘s so simple

最新推荐文章于 2024-04-05 00:37:31 发布

阅读量526

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/weixin_43937101/article/details/115317224

版权

C++ 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

文章目录

1.引用
2. 内联函数
3.auto用法
4. 指针空值

1.引用

1.1 引用前言

在未学引用概念之前，我们在声明一个swap函数的时候，通常是怎么实现的呢？下面有三种实现swap功能的代码，我们首先来对其逐一分析分析。

代码1

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

看到这里，肯定有很多人会发现代码1是行不通的，无法真正的对a，b进行交换，因为在调用swap函数的时候，传过去的参数是只是一个临时的副本空间，在这个空间里进行修改，当函数执行完之后，该函数的栈帧也会被销毁，里面传过去的临时空间也会随着销毁，因此，对原本传入参数的空间并没有任何影响。

那就对它进行改进，不传值了，传入一个地址，看看它是否能实现函数的功能。

代码2

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

那么代码2呢？代码2这次传入的不是一个参数的值，而是参数的地址，它能进行正常的交换吗？
我们可以来看一下运行的结果截图：

代码2的运行结果：

答案是不能，传递地址过去，直接交换地址，也不能实现swap函数的功能。
为什么不能呢？用图来大致解释一下

①当调用到swap函数的时候，会建立一个swap函数的栈帧，为形参开辟出两个空间，用来存放传入参数的值

交换前：

②在用一个临时的空间tmp，将其地址交换后，只是将开辟出的两个空间的地址&a和&b发生了交换，但是并没有真正交换&a和&b所指向空间的值

交换时：

交换后：

其实，代码1和代码2在本质上都是相同的，均是传入了一个值进去，即为按值传递。

那就再进行改进，结合代码1和代码2的错误，代码3就实现了能既在传地址过去的同时还能修改地址中的值,实现对应功能。

代码3

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

我们可以看下运行的截图：

代码3的与运行结果：

可以发现，a 和 b 的值按照我们所想的那样，实现了交换。

这种方法也是现在大多数人所采用的方法，但说起来还是有点不好，因为每次在调用该函数的时候，都要在栈帧中创建两个临时空间，如果当要交换的数据量比较大的时候，这种实现岂不是效率会比较低，那还要更好的方法吗？

C++就引入了按引用传递的办法，会比上面的方法效率更优一些。

1.2 引用概念及其特性

概念：

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

格式：类型& 引用变量名(对象名) = 引用实体

举个例子就是：

int a = 10;
int &b = a;

b就是a的引用，他们共用一块的内存，就相当于给a这个变量，起了个外号，他家人叫他是叫名字，他朋友叫他是叫他的外号，就是这个道理，叫的不一样，但是叫的人是相同的人。比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。

这里需要注意的是：引用类型必须和引用实体是同种类型的。

特性：

引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体

引用的场景：

做参数
做返回值

这里需要注意的是，如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。简单来说就是当将引用用作返回值的时候，如果返回的值的空间在函数结束后就被销毁，那么就不能将其引用返回给空间。如果函数结束后，他还留在空间中(这种情况一般是静态变量、在堆上申请的空间以及全局变量 )，那么，他就可以返回其引用值。

1.3 常引用

在引用的类型前面加上const关键字，即可表明它是一个常引用。

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;
}

在此，我们顺便实现一下，按引用传递实现swap函数。

代码4

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

运行截图：

代码4的运行结果：

1.4 效率对比以及引用与指针的区别

在说区别之前，我们首先来对比一下按引用传递和按值传递之间的效率，看看引用是否有说的那么神奇。

效率对比

代码如下：

#include <iostream>
#include <time.h>

using namespzce std;

struct A{ int a[10000]; };

void TestFunc1(A a){}

void TestFunc2(A& a){}

void TestRefAndValue()
{
 A a;
 // 以值作为函数参数
 size_t begin1 = clock();
 for (size_t i = 0; i < 10000; ++i)
 TestFunc1(a);
 size_t end1 = clock();
 // 以引用作为函数参数
 size_t begin2 = clock();
 for (size_t i = 0; i < 10000; ++i)
 TestFunc2(a);
 size_t end2 = clock();
 // 分别计算两个函数运行结束后的时间
 cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
 cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

运行结果如下：

可以看出两者之间的效率差距还是比较大的

引用与指针的区别

相同点：

引用在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间，
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

不同点：

引用在定义时必须初始化，指针没有要求
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
没有NULL引用，但有NULL指针
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但是没有多级引用
访问实体方式不同，指针需要显式解引用，引用编译器自己处理
引用比指针使用起来相对更安全

2. 内联函数

内联函数：以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。

碎片知识：函数压栈产生的开销一般是现场保护(程序计数器)和现场恢复(上下文信息)时产生的消耗。

特性：

inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

3.auto用法

3.1 auto概念

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它，但是在C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

假设我们要求一个程序中某个变量的类型，我们可以使用type(VirName).name()，其中VirName是该变量的名字，使用该方法即可求得变量的类型，但是在现实中，当我们要求这个变量的类型(我们事先不知道该变量的类型)时，一个一个的用上面的语句进行测试再赋值肯定不符合我们程序员的脾气，因此，就可以采用auto方法，将这个推导类型的难题丢给编译器，让编译器自己去进行推导即可。

但是需要注意的是使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

3.2 使用细则

auto与指针和引用结合起来使用

用auto声明指针类型时，用 auto和 auto* 没有任何区别，但用auto声明引用类型时则必须加&
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;

在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
auto a = 1, b = 2; 
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同

3.3 auto不能推导的场景

auto不能作为函数的参数
auto不能直接用来声明数组
为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等
进行配合使用。

auto也可以用来代替for对有范围的数组进行循环迭代
例如：

int array[] = { 1, 2, 3, 4, 5 };
 for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
 		array[i] *= 2;

可以变为：

for(auto& e : array)
	 e *= 2;

但是也是有相对应的使用条件的：

for循环迭代的范围必须是确定的
迭代的对象要实现 ++ 和 == 的操作

4. 指针空值

在学C的时候，我们知道对一个指针赋值为空，是直接使用NULL即可，NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void)的常量*，这在某些情况下还是造成一些问题，因此针对这种情况，在C++11的时候，引入了一个关键字nullptr，他不包含在头文件中，并且在C++11中，sizeof(nullptr) 与sizeof((void*)0) 所占的字节数相同。

It‘s so simple

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++：详解按引用传递、内联函数，auto用法、指针空值

文章目录1.引用1.1 引用前言1.引用1.1 引用前言在未学引用概念之前，我们在声明一个swap函数的时候，通常是怎么实现的呢？下面有三种实现swap功能的代码，我们首先来对其逐一分析分析。代码1void swap(int a,int b) { int tmp = a; a = b; b = tmp; } 看到这里，肯定有很多人会发现代码1是行不通的，无法真正的对a，b进行交换，因为在调用swap函数的时候，传过去的参数是只
复制链接

扫一扫