[C++知识库]C++初识（四）--- 内联函数&auto&nullptr

🚀前言

这是最后一篇C++初识了，后面会继续更新新的内容…
最近几天下?暴雨?，大家注意安全，感谢大家支持！！！😁

🚃内联函数

🚄1.1、内联函数的概念

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

inline void Swap(int& x, int& y)
{
   int tmp = x;
   x = y;
   y = tmp;
}

int main()
{
   int a = 10, b = 20;
   Sweap(a, b);
}

为什么C++要出inline？

• 为了解决C++中宏的缺陷
• 解决宏函数晦涩难懂，容易写错的问题
• 宏不支持调Debug（调试）

//当很久没写宏时，可能会出现以下错误
//#define Add(int x, int y) return x + y;
//#define Add(x, y) return x + y;
//#define Add(x, y) (x + y)
//#define Add(x, y) x + y;

#define Add(x, y) ((x) + (y)) //正确写法

int main()
{
   int ret1 = Add(1, 2);
   int ret2 = Add(-1, -1);
   if(Add(1, 2)) {}
   return 0;
}

• 函数被inline修饰将其改成内联函数，在编译期间编译器会用函数体替换函数的调用

查看的方式：

1. 在release模式下，查看编译器生成的 汇编代码中是否存在call Add
2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2013的设置方式)

• 打开解决方案管理器，右击打开属性
• 展开C/C++，点击常规，把调试信息格式修改程序数据库
• 点击优化，将内联函数扩展改成只适用于_inline

🚅1.2、内联函数的特性

• inline是一种以空间换时间的做法，省去调用函数额开销
• 代码很长或者有循环/递归的函数不适宜使用作为内联函数

//子函数代码过长
inline void Test1()
{
   int a = 0;
   a += 1;
   a += 1;
   a += 1;
   a += 1;
}

//递归
void Test2()
{
   Test2();
}

• inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉它
• inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，符号表就没有函数地址了，链接就会找不到

Test.h
#include <iostream>
void f();

Test.cpp
#include "Test.h"
using namespace std;

inline void f()
{
   cout << "This is a function decorated with inline" << endl;
}

main.cpp
#include "Test.h"

int main()
{
   f();
}

// 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f()" (?
//f@@YAXH@Z)，该符号在函数 _main 中被引用

总结：?????

• 宏的优点

1. 增强代码的复用性
2. 提高性能

• 宏的缺点

1. 不方便调试宏（因为预编译阶段进行了替换）
2. 导致代码可读性差，可维护性差，容易误用
3. 没有类型安全的检查

C++有哪些技术替代宏？?????

1. 常量定义替换使const
2. 函数定义替换使用内联函数

🚃auto关键字(C++11)

🚇2.1、概念

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

int TestAuto()
{
   return 10;
}

int main()
{
   int a = 10;
   auto b = a;
   auto c = 'a';
   
   auto d = TestAuto();
   cout << typeid(b).name() << endl;
   cout << typeid(c).name() << endl;
   cout << typeid(d).name() << endl;
   
   //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
   return 0;
}

注意：typeid运算符可以判断对象是何类型，name成员函数显示输出类型的字符串（打印随编译器而异）

🚈2.2、auto的使用规则

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

• auto修饰的变量auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
• 在对被const修饰的变量进行类型推导时，会省略const
• 在对被const修饰的指针和引用进行类型推导时，不会省略const

int main()
{
   int x = 10;
   auto a = &x;
   auto* b = &x;
   auto& c = x;
   cout << typeid(a).name() << endl;
   cout << typeid(b).name() << endl;
   cout << typeid(c).name() << endl;

   *a = 20;
   *b = 30;
   c = 40;
   return 0;
}

可以在同一行进行多个初始化的推导吗？：

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

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

🚉2.3、auto的意义

意义：

• 类型很长时，可以让他自动推导，适用于偷懒😂
• auto主要适用于以后学习的迭代器
• 在范围for循环中也会经常使用到它，虽然可以自定义类型

int main()
{
	//auto x;

	std::vector<int> v(2);
	v[0] = 0;
	v[1] = 1;

  //auto意义之一：类型很长时，懒得写，可以让他自动推导
	std::vector<int>::iterator It = v.begin();
	auto It2 = v.begin();

    // 使用auto自动推导容器中数据的类型
	for(auto e : v)
	   cout << e << endl;

    // 使用自定义类型
	for(int e : v)	   
	   cout << e << endl;

🚌2.4、auto不能推导的场景

auto不能作为函数的参数和返回类型

• 在编译阶段时，编译器将提前开辟需要调用的子函数栈帧，因为类型无法确定，所以不行
• auto作为返回类型时，可能导致传参过于自由，不知道需要传什么类型好，没有束缚
• “这是最为让人唾弃的行为”

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{
}

auto TestAuto(int a, int b)
{
   return a + b;
}

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

🚍1.1、范围for的语法

在C++98中如果要遍历一个数组，可以按照以下方式进行：

voidTestFor()
{
   int array[] = { 1, 2, 3, 4, 5 };
   int n = sizeof(array)/sizeof(int);
   
   for(int i = 0; i < n; ++i)
   {
      array[i] *= 2;
   }
   
   // C++98遍历数组的方法
   for(int i = 0; i < n; ++i)
   {
      cout << array[i] << ' ';
   }
   cout << endl;
}

• 对于一个有范围的集合而言，我们对其范围进行求解是多余的，并且容易出错
• 基于for循环后的括号由"冒号"分为两部分组成：
• 第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围

void Test()
{
   int array[] = { 1, 2, 3, 4, 5 };
   
   for (auto& e : array)
      e *= 2;
      
   //array中的元素将依次赋值给e
   //循环将自动判断结束
   for (auto e : array)
      cout << e << ' ';
}

注意：

1. 迭代变量加引用，引用将指向array内部的数据，可以对其进行修改…
2. 它与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环

🚎1.2、范围for循环的使用条件

1. for循环的迭代条件必须是有效的

• 对于数组而言，循环迭代条件为数组首元素到尾元素的范围
• 对于容器而言，需提供begin和end方法，根据begin和end的范围进行迭代

// 数组名传参会降维成指针，导致范围不确定
void TestFor(int array[])
{
   for (auto e : array)
   {
      cout << e << ' ';
   }
   cout << endl;
}

注意：以上代码就有问题，因为for的范围不确定

2. 迭代的对象要实现++和==的操作（以后说明，了解一下）

🚃空指针nullptr（C++11）

🚐1.1、C++98中的空指针

• 在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误
• 比如未初始化的指针（野指针）如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

void TestPtr()
{
   //C语言版本
   int* p1 = NULL;
   int* p2 = 0;
   //C++版本
   int* p3 = nullptr;
}

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

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

• 可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量
• 不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：

void f(int)
{
   cout << "f(int)" << endl;
}

void f(int*)
{
   cout << "f(int*)" << endl;
}

int main()
{
   f(0);
   f(NULL);
   f((int*)NULL);
   f(nullptr)
   return 0;
}

• 程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖
• 在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量
• 但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0

注意：

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

C++初识已写完，感谢大家支持！！！

创作打卡挑战赛

赢取流量/现金/CSDN周边激励大奖