从C语言到C++③(第一章_C++入门_下篇)内联函数+auto关键字(C++11)+范围for+nullptr(上)

简介: 从C语言到C++③(第一章_C++入门_下篇)内联函数+auto关键字(C++11)+范围for+nullptr

1. 内联函数

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

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

C语言可以用宏来优化,比如下面这个两数相加的函数,可以写一个宏代替

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

宏有时候用起来似乎比较复杂,也容易出错。设计C++的大佬就弄出了内联函数来解决。


1.1 内联函数的概念

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

编译时 C++ 编译器会在 调用内联函数的地方展开

没有函数调用建立栈帧的开销,内联函数可以提升程序运行的效率。

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

(就是在以前写的函数前面+inline)

#include <iostream>
using namespace std;
 
inline int Add(int x, int y) 
{
    int ret = x + y;
    return ret;
}
 
int main()
{
    cout << "内联函数: " << Add(1, 2) << endl;
 
    return 0;
}

1.2 内联函数的特性

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

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

(内联内敛,内部关联)

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

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

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

如果展开,编译后台合计会有 10 * 1000 条指令,(所以内联函数适用于频繁调用的小函数

这是一场以空间换取时间的交易。因为没有了函数压栈的开销,所以能提高程序运行的效率。

注意事项:

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

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

③ inline 申明和定义不建议分离,分离会导致链接错误。内联函数会在调用的地方展开,导致不生成地址,链接(如平常写的Test.cpp)就会找不到。所以内联函数一般在.h或源文件直接实现。

1.3 宏的优缺点和替代方法

优点:

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

② 宏有助于提高性能

缺点:

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

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

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

C++有哪些技术替代宏?(C++中基本不再建议使用宏)

1. 常量定义 换用const enum

2. 短小函数定义 换用内联函数(内联函数几乎解决了宏的缺点和兼具了宏的优点)


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

2.1 改版前的auto

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

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

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

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

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

但是因为后来C语言把标准给改了,不加也是自动销毁:这么一来,这个 auto 关键字就没有意义了,因为都是自动销毁。

2.2 C++11的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.01;
    auto pa = &a;
    // typeid - 打印对象的类型
    cout << typeid(a).name() << endl;
    cout << typeid(c).name() << endl;
    cout << typeid(ch).name() << endl;
    cout << typeid(e).name() << endl;
    cout << typeid(pa).name() << endl;
    return 0;
}

这时候可能有人会觉得,这一波操作好像也没啥意义啊,直接写数据类型不方便吗?  


2.3 auto 的使用场景

处理很长的数据类型:

在后面学完STL遇到这种场景,就能体会到 auto 的方便了:

#include <iostream>
#include <map>
 
int main() 
{
    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 非常聪明,它在推导的时候其实是非常灵活的:

int main()
{
    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的初始化表达式类型不同

2.4 使用auto的注意事项

①使用 auto 是必须要给值的

int i = 0;
auto j; // 报错
 
auto j = i; // 必须给值

使用 auto 定义变量时必须对其进行初始化,

在编译阶段编译器需要根据初始化表达式来推导 auto

的实际类型。因此 auto 并非是一种 “ 类型 ” 的声明,而是一个类型声明时的 “ 占位符 ” ,

编译器在编 译期会将 auto 替换为变量实际的类型

②auto 不能作为函数的参数 auto 不能作为形参类型,因为编译器无法对a的类型进行推导。


③auto 不能直接用来声明数组


④用auto声明指针类型时,用auto和auto*没有任何区别,但用auto声明引用类型时则必须 加&。


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


auto 在实际中最常见的优势用法就是 C++11 提供的新式 for 循环,


还有 lambda 表达式等进行配合使用。

3. 范围 for(C++11)

在以前的C语言和 C++98 中如果要遍历一个数组,可以按照以下方式进行:

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 循环。

从C语言到C++③(第一章_C++入门_下篇)内联函数+auto关键字(C++11)+范围for+nullptr(下):https://developer.aliyun.com/article/1513639?spm=a2c6h.13148508.setting.19.5e0d4f0emCh6wU

目录
相关文章
|
1月前
|
C语言 C++
C 语言的关键字 static 和 C++ 的关键字 static 有什么区别
在C语言中,`static`关键字主要用于变量声明,使得该变量的作用域被限制在其被声明的函数内部,且在整个程序运行期间保留其值。而在C++中,除了继承了C的特性外,`static`还可以用于类成员,使该成员被所有类实例共享,同时在类外进行初始化。这使得C++中的`static`具有更广泛的应用场景,不仅限于控制变量的作用域和生存期。
45 10
|
1月前
|
存储 安全 编译器
【C++】C++特性揭秘:引用与内联函数 | auto关键字与for循环 | 指针空值(一)
【C++】C++特性揭秘:引用与内联函数 | auto关键字与for循环 | 指针空值
|
29天前
|
C语言 C++
实现两个变量值的互换[C语言和C++的区别]
实现两个变量值的互换[C语言和C++的区别]
16 0
|
1月前
|
存储 编译器 程序员
【C++】C++特性揭秘:引用与内联函数 | auto关键字与for循环 | 指针空值(二)
【C++】C++特性揭秘:引用与内联函数 | auto关键字与for循环 | 指针空值
|
1月前
|
程序员 C++ 开发者
C++入门教程:掌握函数重载、引用与内联函数的概念
通过上述介绍和实例,我们可以看到,函数重载提供了多态性;引用提高了函数调用的效率和便捷性;内联函数则在保证代码清晰的同时,提高了程序的运行效率。掌握这些概念,对于初学者来说是非常重要的,它们是提升C++编程技能的基石。
21 0
|
17天前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象(下)
【C++打怪之路Lv5】-- 类和对象(下)
20 4
|
17天前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象(中)
【C++打怪之路Lv4】-- 类和对象(中)
18 4
|
17天前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
17 1
|
27天前
|
存储 编译器 C++
【C++类和对象(下)】——我与C++的不解之缘(五)
【C++类和对象(下)】——我与C++的不解之缘(五)
|
27天前
|
编译器 C++
【C++类和对象(中)】—— 我与C++的不解之缘(四)
【C++类和对象(中)】—— 我与C++的不解之缘(四)