【哇! C++】内联函数、auto关键字、基于范围的for循环、指针空值nullptr

jp_yc

已于 2025-02-14 16:35:35 修改

阅读量556

点赞数 17

文章标签： c++ 开发语言

于 2025-02-14 16:31:01 首次发布

本文链接：https://blog.youkuaiyun.com/jp_yc/article/details/145627672

版权

一、内联函数

1.1 宏函数

调用1次函数，需要构建1个栈帧。如果频繁的调用一个函数n次，就需要建立n个栈帧。C语言通过宏函数（宏是预处理阶段进行替换，不用建立栈帧）解决这个问题。

不是函数，所以没有参数这个概念；
没有分号；
括号控制优先级。

#define ADD(int a, int b) return a + b;//err
#define ADD(a, b) a + b;//err
#define ADD(a, b) (a + b)//err
#define ADD(a, b) ((a) + (b))//ok
//为什么要加里边的括号？
//应对a和b可能是表达式

/*int Add(int a, int b)
{
	return a + b;
}*/

int main()
{
    if(ADD(1, 2))
    {

    }
    ADD(1, 2) * 3;

    int x = 1, y = 2;
    ADD(x | y, x & y);//如果不带括号：x | y + x & y，加法优先级比按位或按位与高
    return 0;
}

但是，宏的使用也存在一定的缺点：1. 语法复杂，不容易控制；2. 不能调试；3. 没有类型安全的检查。

为应对宏带来的不便，C++采用了inline。

1.2 内联函数的概念

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

特点：在调用的地方展开，把函数的运算逻辑放进来，而不创建栈帧。

#include<iostream>

inline int Add(int a, int b)
{
    return a + b;
}

int main()
{
    int ret1 = Add(1, 2) * 3;

    int x = 1, y = 2;
    int ret2 = Add(x | y, x & y);

    return 0;
}

那是否把所有函数都变成内联，就不用栈帧了，可以吗？ - 不行，内联也是有缺点的。

假设func函数100行，调用1w次，会有一定程度的代码膨胀的。代码膨胀的缺点：编译好可执行程序会变大。即：

1) 假设inline展开了，需要100*1w行；2) 假设inline不展开，需要100+1w行。

1.3 内联函数的使用

内联函数不建议声明和定义分开。

//Stack.h
#pragma once
#include<iostream>
using namespace std;

inline int Add(int a, int b)；

/
//Stack.cpp
#include"Stack.h"

inline int Add(int a, int b)
{
    cout << "int Add(int a, int b)" << endl;
    return a + b;
}

/
//Test.c
#include"Stack.h"
int main()
{
    Add(1, 2);
    return 0;
}

报错显示无法解析，就是找不到Add函数。编译器把地址加到符号表，是为了让其他文件调用方便，而编译器认为内联函数inline在调用的地方要展开，就没有函数地址了，链接就会找不到。

另外，要在.h中定义函数，例如：

//Stack.h
#pragma once
#include<iostream>
using namespace std;

int Add(int a, int b)
{
    cout << "int Add(int a, int b)" << endl;
    return a + b;
}

/
//Stack.cpp
#include"Stack.h"

/
//Test.c
#include"Stack.h"
int main()
{
    Add(1, 2);
    return 0;
}

出现了链接错误。以往常见的是找不到定义会报错，现在还有一种重定义也会出现连接错误。

这是因为，Test.cpp和Stack.cpp文件下在链接的时候均有Add函数，最后要把生成Test.o和Stack.o合并在一起，并且不构成函数重载，所以编译器认为定义了同样的函数。

例如：Stack.cpp和Test.cpp中分别生成了一份符号表，且分别假设为call Add(0x00112233)和call Add(0x001122ff)，在两个地址处都定义了Add。

#pragma once解决的是：在同一个文件内重复包含。

#pragma once
//预处理条件编译的时候，只保留一个，另一个会自动删掉
#include"Stack.h"
#include"Stack.h"

现在是同一个函数在两个文件中包含，最后导致链接错误。这个问题应该怎么解决？

1) 声明和定义分离，防止链接冲突。

#include"Stack.h"//展开只有声明，没有定义

int main()
{
	Add(1, 2);//汇编的时候没有地址call Add(?)，最后拿修饰后的函数名链接的时候去符号表中找，并在Stack.cpp文件中找到了

	return 0;
}

2) 假设就要在Stack.h中定义，在.h中函数用static修饰

静态的特点：修饰函数的时候，会改变函数的链接属性，只在当前文件可见，不会进符号表。不是在静态区，编译好的程序都在代码区；只有静态的变量才在静态区。

3) inline - 内联是不支持声明和定义分离的

内联函数不会将函数名的地址加入符号表，所以不会冲突。

//Stack.h
#pragma once
#include<iostream>
using namespace std;

inline int Add(int a, int b)
{
    cout << "int Add(int a, int b)" << endl;
    return a + b;
}

/
//Stack.cpp
#include"Stack.h"

/
//Test.c
#include"Stack.h"
int main()
{
    Add(1, 2);
    return 0;
}

综上所述：要在.h中定义函数，大函数声明和定义分离或静态；小函数内联，因为函数代码很长，内联不会展开。

二、auto关键字

2.1 auto - 自动推导类型

auto修饰的变量，是具有自动存储器的局部变量。

int main()
{
	int i = 0;
	int j = 0;
	auto k = i;//ok
	//auto x;//err
    //与引用类似，必须初始化，等号右边必须有一个值，通过这个值来自动推导类型
	auto p1 = &i;//ok
	auto* p2 = &i;//ok
	//auto* p3 = i;//err

	auto& r = i;//ok，代表r是i的别名

	return 0;
}

2.2 auto的价值与应用场景

void func(int a, int b)
{
    //
}

int main()
{
    void(*pf1)(int, int) = func;//初始化函数指针
    auto pf2 = func;//这样使用auto就简化许多

	//C++中可以打印类型 - typeid(对象).name
	cout << typeid(pf1).name() << endl;
	cout << typeid(pf2).name() << endl;
    
    return 0;
}

auto的价值在于：当面对类型写起来很繁琐（如：数组指针，函数指针等），或者类型写起来很长，可以直接用auto自动推导出对应的类型。

但是auto也有一定的弊端：1) 会一定程度上影响可读性；2) auto不能做参数，例如：void TestAuto(auto a) {}；3) 新标准下，auto可以做返回值，但比较坑，例如：

auto f2()
{
	auto ret = 1;
	return ret;
}
auto f1()
{
	auto x = f2();
	return x;
}
auto TestAuto()
{ 
	auto a = f1();
	return a;
}

int main()
{
	auto it2 = TestAuto();
    //此时，it2是什么类型？回去看函数的声明，返回的是a
    //a是什么类型？得回看f1
    //x是什么类型？得回看f2

	return 0;
}

三、基于范围的for循环

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

int main()
{
	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;

	return 0;
}

范围for是C++增加的新语法。如下边程序所示：依次取数组中的值赋值给e（e就是array数组中的数字的一份拷贝），自动迭代，自动判断结束。

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

	for (auto e : array)//这里用int也可以，但是用auto更好
	{
		e *= 2;//e是array中数据的临时拷贝
	}
	cout << endl;

	for (auto& e : array)//还把array中的数据给e，但此时e不是拷贝，而是别名
	{
		e *= 2;
	}
	cout << endl;

	for (auto e : array)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

四、指针空值

void f(int)
{
	cout << "f(int)" << endl;
}
void f(int*)
{
	cout << "f(int*)" << endl;
}
int main()
{
	f(0);//f(int)
	f(NULL);//f(int) 在C++98中出现了bug，把NULL作为是一个宏，宏定义NULL为0
	f((int*)NULL);//f(int*)

	return 0;
}