内联函数与auto关键字与nullptr

Hungry_11

于 2024-08-18 13:49:26 发布

阅读量342

点赞数 11

分类专栏： C++程序设计文章标签：开发语言 c++

本文链接：https://blog.csdn.net/m0_74093370/article/details/140105046

版权

C++程序设计专栏收录该内容

5 篇文章 0 订阅

订阅专栏

内联函数与宏

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
内联类似宏，但是比宏好用，以常见的#define ADD(a + b) a + b为例，这样写就是错误的，很容易造成运算错误，要不停的加括号。但是在相应的地方加上宏又能提高运行效率。于是C++内联函数就解决了宏的缺点，又保留的其提高运行效率的优点。

inline int Add(int a, int b)
{
	return a + b;
}
int main()
{
	int ret1 = Add(1, 2) * 3;
	return 0;
}

在函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的
调用。
在这里插入图片描述
如上图，如果不加inline，调用函数的时候就会建立栈帧，增加运行时间，但是inline就像宏替换一样，直接将函数展开，没有调用函数的过程。

上图显示的汇编要对编译器配置一下才可以，否则还是会显示是call关键字，也就是调用相关函数，而不是函数展开。因为编译器要方便调试，在debug模式下还是会进到函数体内部。

在工程的属性页进行相应的配置即可。

但是不是所有的函数都可以使用内联的，当函数比较复杂时，函数调用的时空开销可以忽略，大部分的 CPU 时间都会花费在执行函数体代码上，所以我们一般是将非常短小的函数声明为内联函数。而且inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、循环，且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

下图为《C++prime》第五版关于inline的建议：
在这里插入图片描述

内联与链接

ifndef防止重复定义和重复展开，防止重复定义是重点。如果没有加ifndef，就会直接或间接重复定义变量。

但是有一点无法避免，就算是加了ifndef，也会报错。比如在头文件里面定义函数或者两个C文件都有一个相同的函数。如果两个C文件都包含了此头文件，就会报链接错误。我们包含头文件，然后预编译的时候展开，展开后就相当于在此C文件定义了一个函数，两个C定义同一个函数，就会报错。因为在彼此C文件对应的符号表里面存在一个同样的地址，在链接过程就会报错。

解决方案:

最常用的就是定义与声明分离，我们在调用函数的时候，当没有此函数，但是声明过，就会去符号表里面找，找到了以后就去到对应的C文件调用函数。
定义静态，静态就是只在当前文件可见，底层就是不进入符号表，就是我们在头文件中定义的函数使用静态关键字。既可以在头文件里面这样使用也可以在cpp文件里面使用，在头文件中这样使用，那么包含此头文件的文件都包含这样一个函数，对外部不可见，只对自己的文件可见。

使用内联函数，内联函数不支持定义与声明分离，因为内联的本质就是展开，没有函数地址，因此内联函数也不会进符号表。
如果内联函数声明与定义分离的话也会报链接错误，但是链接错误报的不是链接冲突，而是无法解析的外部符号，因为我们调用的函数在文件中没有。内联函数的地址是不进入符号表的，所以找不到，就会报无法解析的外部符号。
也就是说不能在某个C文件用内联定义，然后在头文件里面声明，最后在另一个C文件调用。

通过上述规则，我们可以知道，我们可以在某个头文件中用内联定义函数，这样包含这个头文件的就有这个函数了。但是内联不建议复杂函数使用，如果函数比较大的话就可以使用静态定义。

auto

auto使用

auto是什么

auto是C++的一个关键字
在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。
C++11中，标准委员会赋予了auto全新的含义即：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;
}

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;
	cout << x << endl;
	return 0;
}

typeid().name()可以用来查看变量的类型

在这里插入图片描述

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

在对一些较长的函数类型，比如函数指针的时候用auto就十分方便

int func(int a, int b)
{
	return 1 + 2;
}
int main()
{
	int (*pf1)(int, int) = func;
	auto pf2 = func;
	cout << typeid(pf1).name() << endl;
	cout << typeid(pf2).name() << endl;
	return 0;
}

在这里插入图片描述

我们也可以使用typedef对类型名进行重命名，也可以简化代码，比如对函数指针重命名就是
typedef int (*PTypeFun2)(int, int); // 声明一个函数指针类型
但是对下面代码就容易出错

typedef char* pstring;
int main()
{
	const pstring p1;
	const pstring* p2;
	return 0;
}

const pstring 实际上相当于const char* 吗？不是的，它实际上相当于char* const。
原因在于const给予了整个指针本身以常量性，也就是形成了常量指针char* const。
简单来说，记住当const和typedef一起出现时，typedef不会是简单的字符串替换就行。

所有上述代码p1就要进行初始化，不初始化会报错，因为p1被const修饰，必须要有初始值，而p2就不需要初始化，因为const修饰的是*p2。

在同一行定义多个变量

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

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

auto不能推导的场景

auto不能作为函数的参数

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

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

auto不能直接用来声明数组

void TestAuto()
{
	int a[] = {1,2,3};
	auto b[] = {4，5，6};//错误的用法
}

auto不能直接用来声明数组，数组类型在C++中是一种复杂的类型，当使用auto声明数组时，编译器无法确定对应数组的类型，因为数组可能会转化为指针，并且在声明时无法推断数组的长度。

基于范围的for循环

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

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

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

void TestFor()
 {
 int array[] = { 1, 2, 3, 4, 5 };
 for(auto& e : array)
 e *= 2;
 for(auto e : array)
 cout << e << " ";
 return 0;
 }

使用auto关键字，可以简单的进行遍历数组

void TestFor()
{
	int array[] = { 1, 2, 3, 4, 5 };
	for (auto& e : array)//这里是引用类型才可以改变数组的值
		e *= 2;
	for (auto e : array)
		cout << e << " ";
}

在这里插入图片描述

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

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

对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供
begin和end的方法，begin和end就是for循环迭代的范围。

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

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

指针空值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*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(int*)0。
为了避免NULL引起的错误，C++11就定义了nullptr