【C++要笑着学】内联函数 | 关键字auto | 范围for | 关键字 nullptr

举报
柠檬叶子C 发表于 2022/04/04 09:28:41 2022/04/04
【摘要】 本章将继续讲解C++入门部分的知识,将对内联函数、改版后的auto关键字、范围for,以及指针空值nullptr 等知识点进行讲解。

写在前面:

本章将继续讲解C++入门部分的知识,将对内联函数、改版后的auto关键字、范围for,以及指针空值nullptr 等知识点进行讲解。


Ⅰ.  内联函数

0x00 问题引入

 调用函数,需要建立栈帧,栈帧中要保留一些寄存器,结束后又要恢复。

这就可以看出这些都是有消耗的,对于频繁调用的小函数,有没有方法可以优化呢?

💬 比如下面这个两数相加的函数:

int Add (int x,int y) {
    int ret = x + y;
    return ret;
}

💡 我们可以写一个两数相加的宏:

#include<iostream>
using namespace std;

int Add(int x, int y) {
    int ret = x + y;
    return ret;
}

// 写一个两数相加的宏
#define ADD(X, Y) ((X) + (Y))

int main(void)
{
    cout << "函数: " << Add(1, 2) << endl;
    cout << "宏: " << ADD(1, 2) << endl;
    // 写宏的技巧:记住宏原理是替换,你替换一下看看对不对
    // cout << "M: " << ((1) + (2)) << endl;

    cout << "宏: " << 10 * ADD(3, 4) << endl;
    return 0;
}

🚩 运行结果如下:


0x01 内联函数的概念

 宏有时候用起来似乎比较复杂,也容易出错。我们可以使用C++中的内联函数来解决。

📚 概念:以 inline 修饰的函数叫做内联函数。

语法:inline 数据类型 [函数名]


💬 代码演示:

#include <iostream>
using namespace std;

inline int Add(int x, int y) {
    int ret = x + y;
    return ret;
}

int main(void)
{
    cout << "内联函数: " << Add(1, 2) << endl;

    return 0;
}


0x02 内联函数的特性

  特性:以时间换空间,省去了调用函数的开销。

编译时 C++ 编译器会在调用内联函数的地方展开,是没有函数压栈的开销的。


因为他会在编译的时候展开,所以代码很长。举个例子:

inline void func() {
    // 假设有10行代码
}

如果不展开,假设有1000个调用,编译后台就会有 10 + 1000 条指令。

如果展开,编译后台合计会有 10 * 1000 条指令,

所以,这是一场以时间换取空间的交易。

 因为没有了函数压栈的开销,所以能提高程序运行的效率。



📌 注意事项:

inline 既然是以时间换空间的做法,所以代码很长、循环或递归的函数不适宜成为内联函数。

②  inline 对于编译器而言只是一个建议,编译器会自动优化,如果定义为 inline 函数的函数体内油循环或递归等等,编译器优化时会忽略掉内联。

inline 申明和定义不建议分离。内联函数会认为在调用的地方展开,导致不生成地址。test.cpp -> test.o  符号表中不会生成 Func 函数的地址,因为 inline 函数是不需要地址的(都在调用的地方展开了还要个毛线地址)。我们来验证一下:

💬 Add.h:

#include <iostream>
using namespace std;

inline int Func(int x, int y);

💬 Add.cpp:

#define _CRT_SECURE_NO_WARNINGS 1
#include "Add.h"

int Func(int x, int y) {
	return x + y;
}

💬 test.cpp:

#include "Add.h"

int main(void) 
{
	Func(1, 2);

	return 0;
}

🚩 运行结果如下:


0x03 浅谈宏的优缺点和替代方法

❓ 宏的优缺点是什么?

优点:

① 宏可以增强代码的复用性

② 宏有助于提高性能

缺点:

① 宏调试起来很不方便(因为宏在程序预编译阶段进行替换)。

② 宏的大量使用可能会导致代码的可读性差,可维护性差,容易误用。

③ 宏没有类型安全的检查。


有哪些技术可以替代宏?

① 常量定义:换用 const

② 函数定义:换用内联函数



Ⅱ.  auto关键字(C++11)

0x00 改版前的auto

改版前的 auto 指的是在早期 C/C++ 中 auto 关键字的含义。

📚 旧的含义:使用 auto 修饰的变量,是具有自动存储器的局部变量。

 遗憾的是,大家都懒得去用它。这是为什么呢?

auto int a = 0;   // 表示a是一个自动存储类型,会在函数结束后自动销毁。

当使用 auto 修饰后,表示 a 是一个自动存储类型,它会在函数结束以后自动销毁。

但是因为后来 C 把标准给改了,不加是自动销毁:

int a = 0;   // 标准改了之后,不加也是自动销毁。

 这么一来,这个 auto 关键字就没有意义了,因为都是自动销毁。

auto:这就尴尬了,我的存在没有意义了,用和不用都一样。


0x01 改版后的auto

C++标准委员会觉得这 auto 也太尴尬了,我们得给它来一波加强。

为了缓解 auto 的尴尬,C++ 标准委员会把 auto 原来的功能给废弃了。

并赋予了 auto 全新的含义!

📚 新的含义:auto 不再是一个存储类型指示符,而是作为一个新的类型指示符来指示编译器。auto 声明的变量必须由编译器在编译时推导而得。


💬 也就是说,它可以自动推导出数据的类型:

int a = 0;
auto c = a;  // C++11给auto关键字赋予了新的意义:自动推导c的类型

你的右边是什么,它就会推导出相应的类型

任何类型都可以实现,包括但不限于:

auto ch = 'A';
auto e = 10.11;
auto pa = &a;

为了方便测试,我们来打印一下对象的类型看看:

#include<iostream>
using namespace std;

int main()
{
    int a = 0;
    auto c = a;  // 自动推导c的类型

    auto ch = 'A';
    auto e = 10.11;
    auto pa = &a;

    // typeid - 打印对象的类型
    cout << typeid(c).name() << endl;   // i
    cout << typeid(ch).name() << endl;  // c
    cout << typeid(e).name() << endl;   // d
    cout << typeid(pa).name() << endl;  // Pi

    return 0;
}

🚩 运行结果如下:

 emmm... 确实


 这时候可能有人会觉得,这一波操作好像也没啥意义啊,

直接写数据类型不香吗?  int c = a;

我们继续往下看~


0x02 auto 的使用场景

处理又臭又长的数据类型 

💬 遇到这种场景,就能体会到 auto 的香了:

#include <iostream>
#include <map>

int main(void) 
{
    std::map<std::string, std::string> dict = {{"sort", "排序"}, {"insert", "插入"}};
    std::map<std::string, std::string>::iterator it = dict.begin();
    // 这个类型又臭又长,写起来太麻烦了。。。
    
    auto it = dict.begin();   // 可以改成这样,爽!
    // ↑ 根据右边的返回值去自动推导it的类型,写起来就方便多了

    return 0;
}

像遇到这种又臭又长的类型,而且还要经常使用,

这时候使用 auto 帮你自动推到类型,就很爽了!


auto 与指针结合起来使用:

📚 auto 非常聪明,它在推导的时候其实是非常灵活的:

int main(void)
{
    int x = 10;
    auto a = &x;  // int*
    auto* b = &x; // int*
    auto& c = x;  // int

    return 0;
}


在同一行定义多个变量


当在同一行声明多个变量时,这些变量必须是相同的类型!

否则编译器将会报错,因为编译器实际只对第一个类型进行推导,

然后用推导出来的类型定义其他变量。

auto a = 1, b = 2;
auto c = 3, d = 4.0;  ❌ 该行代码会编译失败,因为c和d的初始化表达式类型不同



0x03 使用auto的注意事项

 注意!

使用 auto 是必须要给值的!

int i = 0;
auto j;  ❌

auto j = i;  必须给值!!

这就意味着,auto 是不能做参数的!


auto 不能作为函数的参数

void TestAuto(auto a); ❌

此处代码编译失败,auto 不能作为形参类型,因为编译器无法对a的类型进行推导!


auto 不能直接用来声明数组

 auto b[3] = {4,5,6};   ❌


📌 为了避免与 C++98 中的 auto 发生混淆,C++11 只保留了 auto 作为类型指示符的用法。

 auto 在实际中最常见的优势用法就是 C++11 提供的新式 for 循环,还有 lambda 表达式等进行配合使用。我们可以继续往下看~



Ⅲ.  范围 for(C++11)

0x00 概念

📚 范围 for,即 —— 基于范围的 for 循环。

范围for可以说是一颗 "语法糖" ,什么是语法糖?

就是用起来会让人觉得很甜,很爽的东西~


以前,我们要遍历一个数组,一般会按照以下方式进行:

int main()
{
    int arr[] = { 1, 2,3,4,5 };
    int sz = sizeof(arr) / sizeof(arr[0]);  // 计算数组大小

    int i = 0;
    for (i = 0; i < sz; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

 对于一个有范围的集合而言,让程序员来说明循环的范围是多余的,

有时候还会容易犯错误……

 因此,C++11中引入了基于范围的 for 循环。


📚 语法: for ( auto 变量名 : 数组)

for 循环后的括号由冒号分为两部分:

第一部分:范围内用于迭代的变量

第二部分:表示被迭代的范围


0x01 范围 for 的用法

💬 使用方法演示:

int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };

    for (auto e : arr) {
        printf("%d ", e);
    }
    printf("\n");

    return 0;
}

🚩 运行结果如下:


💬 试着使用范围 for,把数组中的每个值 +1   (1 2 3 4 5 → 2 3 4 5 6)

#include<iostream>
using namespace std;

int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };

    // ++
    for (auto& e : arr) {
        e++;
    }

    // 打印
    for (auto e : arr) {
        cout << e << " ";
    }
    cout << endl;

    return 0;
}

🚩 运行结果如下:

🔑 解读:这里我们可以使用引用来对数组中的每个值进行修改。


📌 注意事项:和普通循环类似,可以用 continue 来结束本次循环,也可以用 break 来跳出整个循环。


0x01 范围 for 的使用条件

for 循环迭代的范围必须是确定的

 对于数组而言,就是数组中第一个元素和最后一个元素的范围;

对于类而言,应该提供 begin end 的方法,begin end 就是 for 循环迭代的范围。


❌ 错误演示:下面的代码就是 for 循环范围不确定!

void TestFor(int arr[]) {
    for (auto& e : arr) {
        cout << e << endl;
    }
}

🔑 这里传递过来的是数组的首元素地址,并不是数组,它会不知道范围是多少,所以会报错。


迭代的对象要实现 ++ 和 == 的操作

(关于迭代器这个问题,后期会讲,现在了解一下留个印象即可)



Ⅳ.  指针空值 nullptr

0x00 C++ 98 中的指针空值

在良好的 C/C++ 变成习惯中,声明一个变量时最好给该变量一个合适的初始值,否则可能会出现不可预料的错误,比如未初始化的指针。

如果一个指针没有合法的指向,我们就需要手动给它置为空。

在之前的C语言教程里,我们都是用 NULL 来解决的:

#include<iostream>
using namespace std;

int main(void)
{
    // C++ 98/03
    int* p1 = NULL;
    int* p2 = 0;

    return 0;
}

🔑 这里的 NULL 其实是一个宏。


📚 C++ 空指针推荐使用 nullptr 来处理

int* p3 = nullptr;

这是 C++11 新增的关键字,以后就不再推荐使用 NULL 了。


📌 注意事项

① 使用 nullptr 表示指针空值时,因为它是关键字,所以不需要包含头文件。

② C++11中,sizeof( nullptr ) 与 sizeof( (void*)0 ) 所占的字节数相同。

③ 为了提高代码的健壮性,在后续表示指针空值的时建议最好使用 nullptr 。


0x01 引入 nullptr 的原因

正如之前所说,NULL 其实是一个宏:

我们打开传统的 C 头文件 (stddef.h) 中可以看到如下代码:

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

可以看到,NULL可能被定义为字面常量0,或者被定义为无类型指针 (void*) 的常量。

不论采取何种定义,在使用空值和指针时,都不可避免地会遇到一些麻烦,比如:

void Func(int)
{
	cout << "Func(int)" << endl;
}
void Func(int*)
{
	cout << "Func(int*)" << endl;
}
int main()
{
	Func(0);
	Func(NULL);
	Func((int*)NULL);

	return 0;
}

🔑 该程序的本意是想通过 Func(NULL) 调用指针版本的 Func(int*) 函数,但是由于 NULL 被定义成0,这么一来就不符合程序的初衷了。

在C++98中,字面常量 0 既可以是一个整型数字,也可以是无类型的指针 (void*) 常量,但是编译器默认情况下会将其看成一个整型常量,如果要将其按照指针方式来使用,必须对其进行强制类型转换 (void*)0 。


 后来C++11引入了指针空值 nullptr 就缓解了这一尴尬现象。

🔺 总结:nullptr 其实就是 0,所以有了 C++11之后,就不再推荐大家使用 NULL 了。




参考资料:

Microsoft. MSDN(Microsoft Developer Network)[EB/OL]. []. .

百度百科[EB/OL]. []. https://baike.baidu.com/.

比特科技. C++[EB/OL]. 2021[2021.8.31]. .

程序员面试宝典[M]. 5. .

📌 笔者:王亦优

📃 更新: 2022.2.23

❌ 勘误:暂无

📜 声明: 由于作者水平有限,本文有错误和不准确之处在所难免,本人也很想知道这些错误,恳望读者批评指正!

本章完。

【版权声明】本文为华为云社区用户原创内容,未经允许不得转载,如需转载请自行联系原作者进行授权。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

举报
请填写举报理由
0/200