C++入门(3)—内联函数、auto、范围for、nullptr

一、内联函数

1、定义

2、特性

接上一小节C++入门(2)—函数重载、引用

一、内联函数

1、定义

内联函数（Inline Function）是C++中的一个特性，主要用于优化小型、频繁调用的函数。内联函数的主要思想是将函数调用替换为函数体的内容，从而减少函数调用的开销。

在C++中，可以通过在函数声明或定义前加上关键字`inline`来声明一个函数为内联函数，例如：

inline int Max(int a, int b) {
    return a > b ? a : b;
}

当编译器看到内联函数的调用时，它会尝试将函数调用替换为函数体的内容，而不是生成函数调用的代码。这样可以消除函数调用的开销，包括参数传递、返回地址的保存和恢复等。

然而，需要注意的是，`inline`关键字只是向编译器发出一个建议，编译器可以选择忽略这个建议。例如，如果函数体很大，或者函数包含循环、递归等复杂结构，编译器可能会选择不进行内联。

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的

调用。

查看方式：

1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add。

2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化)

2、特性

inline是一种以空间换时间的做法（编译出的可执行程序会变慢），如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

下面来看一个问题：

假设swap函数代码有十行，1000个调用swap的地方
swap不是inline时：

swap+调用swap指令，合计是多少行指令?

直接调用：10+1000。

swap是inline时：

swap+调用swap指令，合计是多少行指令?

inline展开：10*1000。

二、auto

1、定义

C++11引入了auto关键字，它可以用于自动推导变量的类型。auto关键字可以让编译器根据变量的初始化表达式来推导变量的类型，从而简化代码。

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

下面这段代码演示了C++11中引入的auto关键字的用法。类型很长时，可以考虑auto关键字自动推导变量的类型，从而简化代码。

#include<iostream>
#include<map>
#include<string>
using namespace std;
int main()
{

	// auto 实际价值 简化代码，类型很长时，可以考虑自动推导
	map<string, string> dict;
	typedef map<string, string>::iterator DictIt;
	//map<string, string>::iterator dit = dict.begin();
	//DictIt dit = dict.begin();
	auto dit = dict.begin();

	return 0;
}

在这段代码中，我们定义了一个名为 dict 的 map 容器，它将字符串映射到字符串。我们还定义了一个名为 DictIt 的类型别名，它是一个指向map容器中元素的迭代器类型。
接下来，我们使用 auto 关键字来自动推导一个名为 dit 的变量的类型，它是一个指向map容器中元素的迭代器类型。由于我们已经定义了 DictIt 类型别名，我们可以使用它来指定迭代器的类型，也可以直接使用 map<string, string>::iterator 来指定迭代器的类型。
但是，使用auto关键字可以让我们更简洁地表达迭代器的类型，而不需要显式地指定类型。
最后，我们在main函数中返回 0，表示程序正常结束。

2、使用场景

1、下面这个例子是auto常规操作，使用 auto 关键字来声明 b 和 c 变量的类型。

int main()
{
	int a = 0;
	auto b = a;
	auto c = &a;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	return 0;
}

使用 typeid 运算符来输出变量 b 和 c 的类型信息，VS中输出结果如下，左为64位环境，右为32位环境。

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

2、auto与指针和引用结合起来使用，auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&。

int main()
{
	int a = 0;
	auto b = &a;
	auto* c = &a;
	auto& d = a;
	return 0;
}

使用 auto 关键字来声明 b、c 和 d 变量的类型。auto 关键字可以让编译器自动推断变量的类型，根据变量的初始化表达式来确定类型。
b 的类型被推断为 int*，因为它被初始化为 &a，即 a 的地址。c 的类型被显式声明为 int*，与 b 的类型相同。d 的类型被推断为 int&，因为它被初始化为 a，即 a 的引用。
需要注意的是，b 和 c 的类型虽然都是指针类型，但它们的声明方式不同。b 的类型是 auto 推断出来的，而 c 的类型是显式声明的指针类型。这两种方式在语义上是等价的，但在代码风格上有所不同。
d 的类型是引用类型，它可以看作是 a 的别名，d 可以直接访问 a 的值。

3、当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

void TAuto()
{
    auto a = 1, b = 2; 
    auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

3、不能使用场景

auto不能直接用来声明数组。此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
```
void TAuto(auto a)
{}
```

auto不能作为函数的参数

void TestAuto()
{
    int a[] = {1,2,3};
    auto b[] = {4，5，6};
}

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

三、范围for(C++11)

我们来对比一下输出数组元素的两种方式。

int main()
{
	int a[] = { 1,2,3,4,5 };
	for (int i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		cout << a[i] << " ";
	}
	cout << endl;
	for (auto& e : a)
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

二者输出结果相同，其中第二种方式就叫范围for。

1、定义

C++11 引入了一种新的循环语句——范围 for 循环（Range-based for loop），它可以用于遍历容器类对象或数组。

范围 for 循环的语法如下：

for (auto& var : container) {
    statement
}

其中，var 是一个变量名，用于存储容器中的元素；container 是一个容器类对象或数组，用于存储要遍历的元素；statement 是要执行的语句块，可以包含多条语句。
在循环头中，使用 auto& 或 const auto& 声明一个引用变量或常量引用变量，它会依次引用容器或数组中的每个元素。在循环体中，直接使用该变量访问容器或数组元素，并执行相应的操作。
范围 for 循环的优点在于语法简洁明了，可以避免下标越界等问题，同时也可以提高代码的可读性和可维护性。它适用于遍历容器或数组中的所有元素，但不适用于需要跳过或删除元素的情况。
注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环

2、使用条件

1、for循环迭代的范围必须是确定的
- 对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供for循环迭代的范围。
2、迭代的对象要实现++和==的操作。

来看一下下面例子中有什么问题？

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

数组作为函数参数：在C++中，当数组作为函数参数时，它会被解析为指向其首元素的指针。因此，你无法在函数内部获取数组的大小。这就导致了你无法在范围for循环中使用数组，因为范围for循环需要知道数组的开始和结束。
使用auto&：在这个上下文中，auto&表示引用类型，但是由于数组被解析为指针，所以这里的e实际上是一个指针，而不是数组中的元素。

四、nullptr

在C++编程中，为变量赋予一个初始值是一种良好的编程习惯，否则可能会引发不可预知的错误，尤其是在处理未初始化的指针时。

如果一个指针没有有效的指向，我们通常会按照以下方式进行初始化：

void TestPtr()
{
    int* p1 = NULL;
    int* p2 = 0;
    // ……
}

在这里，NULL实际上是一个宏，在传统的C头文件(stddef.h)中可以看到如下代码：

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

具体来看，NULL在C++被定义为字面常量0，在C被定义为无类型指针(void*)的常量。但在C++中使用空指针NULL时会引发一些问题。

例如：

#include<iostream>
using namespace std;
void f(int)
{
    cout << "f(int)" << endl;
}
void f(int*)
{
    cout << "f(int*)" << endl;
}
int main()
{
    f(0);
    f(NULL);
    f((int*)NULL);
    return 0;
}

在这个例子中，我们希望通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义为0，所以实际上调用的是f(int)函数，这与我们的初衷相反。

在C++98中，字面常量0既可以被视为一个整型数字，也可以被视为无类型的指针(void*)常量。然而，编译器默认将其视为一个整型常量。如果我们希望将其作为指针使用，必须进行强制类型转换，即(void *)0。

为了解决这个问题，C++11引入了nullptr关键字。nullptr是一个特殊的空指针常量，它的类型是nullptr_t。使用nullptr可以明确地表示一个空指针，避免了与整数0的混淆。

int* ptr = nullptr;  // 声明一个指向整数的空指针
if (ptr == nullptr) {
    // 检查指针是否为空
    // 执行一些操作
}

void foo(int* ptr) {
    if (ptr != nullptr) {
        // 执行一些操作
    }
}

class MyClass {
public:
    void bar() {
        if (this == nullptr) {
            // 在成员函数中使用nullptr检查this指针是否为空
            // 执行一些操作
        }
    }
};

需要注意的是：

使用nullptr表示空指针时，不需要包含任何头文件，因为nullptr是在C++11中作为新关键字引入的。
在C++11中，sizeof(nullptr)和sizeof((void*)0)所占的字节数是相同的。
为了提高代码的健壮性，建议在表示空指针时使用nullptr。