C++ 波澜壮阔 40 年：引用、内联函数与现代空指针，效率跃升三基石

晨非辰2025-12-09 8:15



🔥@晨非辰Tong： 个人主页
👀专栏：《数据结构与算法入门指南》、《C++学习之旅》
💪学习阶段：C语言、数据结构与算法初学者
⏳"人理解迭代，神理解递归。"

文章目录

  • 引言
  • 一、引用：C++前期重难点
    • [1.1 一览：引用的方方面面](#1.1 一览：引用的方方面面)
    • [1.2 划重点：引用的正确使用](#1.2 划重点：引用的正确使用)
    • [1.3 存疑的地方](#1.3 存疑的地方)
    • [1.4 const引用](#1.4 const引用)
    • [1.5 引用和指针的关系（面试必看）](#1.5 引用和指针的关系（面试必看）)
  • 二、inline内联函数
    • [2.1 对要点的详细解释](#2.1 对要点的详细解释)
  • 三、宏：nullptr
  • 总结

引言

C++的演进之路，是不断在性能与安全、灵活与严谨之间寻求平衡的艺术。

本文将深入剖析三大特性："引用"、"内联函数"、"nullptr"。

理解它们，不仅是掌握语法，更是洞察C++设计哲学，书写更高效、更健壮代码的关键一步。

一、引用：C++前期重难点

1.1 一览：引用的方方面面

  • 概念及定义：

引用不是重新定义变量 ，而是给已经定义的变量起一个别名（编译器不会为引用变量开辟内存空间，共用同一块）。

形式：类型& 引用别名 = 引用对象；

C++中为了避免引入太多的运算符，会复用C语言的⼀些符号，比如<<,>>，引用也和取地址使用了同⼀个符号&，注意使用方法角度来区分。

  • 引用的特性：
  1. 引用在定义时必须初始化。
  2. ⼀个变量可以有多个引用。
  3. 引用一旦引用一个实体，再不能引用其他实体。
cpp 复制代码 
#include<iostream>
using namespace std;

int main()
{
	int i = 10;

	//引用：j是i的别名
	int& j = i;

	//多个引用
	int& k = i;
	
	//给别名取别名
	int& a = j;

	//看地址
	cout << &i << '\n';
	cout << &j << '\n';
	cout << &k << '\n';
	cout << &a << endl;

	return 0;
}

（观察地址都是一个变量！）

cpp 复制代码 
#include<iostream>
using namespace std;

int main()
{
	//未初始化引用
	int& j;
	cout << j << endl;
	return 0;
}
cpp 复制代码 
#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	int& b = a;

	//再次引用其他变量相当于赋值
	int c = 20;
	b = c;

	cout << "b=" << b << endl;
	return 0;
}

1.2 划重点：引用的正确使用

  • 引用的主要实践用途是通过引用传参和引用返回来减少数据拷贝提高效率，以及在修改引用对象时同步改变被引用的原对象。（引用返回值相对复杂，先简单了解。）
  • 引用传参跟指针传参功能是类似的，引用传参相对更方便⼀些。
  • 引用和指针相辅相成，并不能完全替代。
  1. 引用传参------>代替指针（大部分情况引用可以代替指针）
cpp 复制代码 
void Swap(int* a, int* b)
{
	if (*a > *b)
	{
		int tmp = *a;
		*a = *b;
		*b = tmp;
	}
}

void Swap(int& rx, int& ry)
{
	if (rx > ry)
	{
		int tmp = rx;
		rx = ry;
		ry = tmp;
	}
}
int main()
{
	int x = 2;
	int y = 1;

	Swap(&x, &y);
	cout << x << ' ' << y << '\n';
	Swap(x, y);
	cout << x << ' ' << y << '\n';
	return 0;
}

在逻辑上，rx,ry是x,y的别名，本质上就是x,y，所以交换rx,ry就是交换x,y。

对于函数传参时，引用的初始化：因为只有调用函数才会定义引用，传参就相当于赋值int& rx = x, int& ry = y。

  • 一级指针的引用：
cpp 复制代码 
#include<iostream>
using namespace std;

void swap(int** x, int** y)
{
	int* tmp = *x;
	*x = *y;
	*y = tmp;
}

void swap(int*& x, int*& y)
{
	int* tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	//swap函数交换指针
	int a = 10; int b = 17;
	int* pa = &a; int* pb = &b;
	swap(&pa, &pb);//用指针
	cout << *pa << " " << *pb << '\n';
	swap(pa, pb);//用引用
	cout << *pa << " " << *pb << '\n';
	return 0;
}

对于链表、树等，节点定义位置，只能使用指针。因为C++的引用无法改变指针指向，但是节点一定存在改变指向的情况。

  1. 引用返回值：
  • 先看传值返回
cpp 复制代码 
#include<iostream>
using namespace std;

//传值返回
int func()
{
	int ret = 0;
	//...
	return ret;
}

int main()
{
	int x = func();

	//func() += 1;
	return 0;
}

看传值返回，func函数返回的其实ret的一个拷贝（相当于临时变量），调用结束，函数销毁，看下面的func() += 1;就会报错。

  • 对比看传引用返回
cpp 复制代码 
#include<iostream>
using namespace std;
//传引用返回
int& func()
{
	int ret = 0;
	//...
	return ret;
}

int main()
{
	int x = func();
	cout << x << endl;
	return 0;
}

看传引用返回，实际上函数返回的是ret的别名（比如tmp）。与传值返回不同的是，函数销毁后，将空间返回操作系统（但仍然指向这块空间），如果别人对空间进行操作，就会改变，这是就相当于野指针的访问！很危险！！

  • 验证上面说法：
      一个很奇怪的结果：
cpp 复制代码 
#include<iostream>
using namespace std;
int& func1()
{
	int ret = 0;
	//...
	return ret;
}

int& func2()
{
	int y = 123;
	//...
	return y;
}

int main()
{
	int& x = func1();
	cout << x << endl;

	func2();
	cout << x << endl;
	return 0;
}

可以看到，我们并没有修改x的值，为什么再次输出x确是y的数值？

已经知道，函数销毁后，将空间返回给操作系统（但是别名x仍然指向这块空间），意味着这块空间可以分配给其他操作 。那么新创建的函数就会在这块空间上，又因为故意的将两个函数结构写的类似，代表二者的栈帧一样大 。

既然栈帧一样大，x就会接收func2返回的别名，也就是y的值。

1.3 存疑的地方

  1. 传引用返回相当于野指针访问，为什么不报错？
    要知道，越界不一定报错！ 数组的越界存在 越界抽查。越界抽查：在临近数组结束的位置进行检查。
  • 越界读：没事
cpp 复制代码 
int main()
{
	int a[10];
	
	//越界读：没事
	a[10];
	return 0;
}
  • 越界写：有事
cpp 复制代码 
int main()
{
	int a[10];
	//越界写：有事
	a[11] = 1;
	a[15] = 1;
	return 0;
}

1.4 const引用

  1. 可以对const对象进行引用，但是必须在类型前加const。const引用也可以引用普通对象，因为对象的访问权限在引用过程中能够减小但是不能放大。
  2. 类似int& rb = a*3; （表达式计算值会存到临时对象中）double d = 12.34; int& rd = d;（类型转换过程将中间值存在临时对象）C++规定这类对象具有常性（只读） ，也就是说需要常引用（避免权限放大）。
  3. 临时对象：编译器需要一个空间暂存表达式的计算结果时创建的一个未命名的对象，C++规定为临时对象。
  • 解释第1条：
cpp 复制代码 
#include <iostream>
using namespace std;

int main()
{
	//const对象
	const int a = 10;

	//权限放大:不能
	int& ra = a;
	return 0;

	//权限缩小：可以
	int b = 10;
	const int& rb = b;
	
	//不属于权限放大
	const int c = 1;
	int rc = c;

	//权限放大缩小，对const 指针&引用
	//权限放大
	const int* p1 = &a;
	int* p2 = p1;

	//权限缩小
	int e = 1;
	int* p3 = &e;
	const int* p4 = p3;
}

不能权限放大： 变量a被const修饰，代表只能读不饿能写，但是后面的引用仿佛在说"可以通过别名对变量进行读写"。但是本体都只能读，一个别名带还想翻天？！，这肯定是错的！（指针同理。但不是别名）


注意下面不属于权限放大： 属于拷贝复制

cpp 复制代码 
#include <iostream>
using namespace std;

int()
{
	const int c = 1;
	int rc = c;
	return 0;
}

可以权限缩小： 本体b可以读写，对于别名rb只进行读是允许的。

函数传参使用const：

以后函数传参都会使用引用，一方面是减少拷贝提高效率，另一方面则是形参会影响实参（少部分）。既然如此，传参以后建议const修饰，这样就可以传普通对象、const对象、常量。

cpp 复制代码 
void func(const int& x)
{

}

int main()
{
	//const int& a = 10;
	int y = 0;
	func(y);

	const int z = 1;
	func(z);
	func(2);
	return 0;
}
  • 解释第2条：

类型转换有：隐式类型转换、显式类型转换（强制类型转换）。

cpp 复制代码 
#include <iostream>
using namespace std;

int main()
{
	//C语言隐式转换
	int i = 0;
	double d = i;

	//强制转换:整型、指针
	int p = (int)&i;
	return 0;
}

对于引用的类型转换： 必须用常引用！

cpp 复制代码 
#include <iostream>
using namespace std;
int main()
{
	int i = 1;
	//double& ri = i;//不行

	const double rd = i;//可以

	//int& pi = (int)&i;//不行

	const int& rp = (int)&i;//可以
	return 0;
}


这就是因为上面说的：会产生临时对象（只读属性），需要对应常引用。

1.5 引用和指针的关系（面试必看）

通常从语法层面来区分，底层层面 只是在特定情况下辅助了解。

  • 语法概念上，引用是变量的别名，不需要另开空间；指针存储一个变量的地址，需要额外空间。
  • 引用在定义时必须初始化；指针建议初始化，语法上不必须。
  • 引用只能引用一个实体，不能改变；指针可以不断改变指向对象。
  • 指针容易出现空指针、野指针的情况；引用很少。
  • 引用可以直接访问引用对象；指针需要解引用。
  • 在sizeof中，引用结果为引用类型的大小；指针始终是地址空间所占的字节数（32位- -4字节，64位- -8字。

二、inline内联函数

  1. 用inline修饰的函数称为内联函数，编译时C++编译器会在调用函数的位置展开函数 ，这样就不需要建立栈帧，提高效率。
  2. 我使用的是VS编译器，debug版本默认不展开inline便于调试。若需要展开，请看下面如何设置。
  3. inline 对于编译器只是一个建议，编译器可以选择执行与否（不同编译器也不同）。inline适用于频繁调用的小函数，对于递归函数、代码多的函数，编译器会忽略inline。
  4. C语言实现的宏函数会在预处理时展开，但实现复杂，易出错，不方便调试。C++设计inline就为了替换宏函数。
  5. inline函数的声明、定义不能分到两个文件（放在同一头文件）。分离会导致内联无法展开，也找不到有效的函数定义，导致连接错误。

2.1 对要点的详细解释

  1. 解释第2条： 如何设置？

找到解决方案资源管理器，鼠标右键你的项目：（红框框）

在弹出的小界面选择属性后：看图示


  1. 解释第3条： inline只是建议

从汇编辅助理解：以简单的函数为例，得出编译器的选择应该有临界值，超过就不展开。

cpp 复制代码 
inline int Add(int a, int b)
{
	a++;
	a++;
	a++;
	a++;
	a++;
	return a + b;
}

int main()
{
	int ret = Add(1, 2) * 3;
	cout << ret << endl;
	return 0;
}
  • 5个a++，选择展开：
  • 10个a++就不展开了：看框框，call就代表调用函数，创建栈帧
  • 划重点，划重点：面试问题：为什么只是"建议"？？！

要完全将选择权交给程序员的话，那么就会发生代码指令恶行膨胀问题，导致可执行程序（安装包）过大！！

参照上后面的5个a++，指令变多了，要是调用的多，局都要展开，更多了。但是不展开，就是单次展开 + 次数 * 函数体，这就少多了。

为了避免问题，就将权力给了编译器。

  1. 解释第4条： 替代宏函数

（C++通过const,enum,inline替代宏。）

为什么C语言的宏函数很坑？

拿ADD宏函数为例：先记住宏就是替换

cpp 复制代码 
//ADD宏函数：第1种
#include <iostream>
#define ADD(int a, int b) return a+b;

第1种错误：根据宏的形式，后面多';'，在后面替换时会导致有两个分号。

cpp 复制代码 
#include <iostream>
using namespace std;
#define ADD(a,b) a + b
int main()
{
	int ret = ADD(1, 2) * 3;
	cout << ret << endl;
	return 0;
}

第2种错误：替换后看似正确，期望输出9，但是由于优先级输出7。

cpp 复制代码 
#include <iostream>
#define ADD(a, b) (a + b)int main()

第3种错误（最接近正确）：改进了第2种，确保输出9。但在a,b都是表达式时，就又会发生优先级的问题。

cpp 复制代码 
#include <iostream>
#define ADD(a, b) ((a) + (b))

第4种：考虑了参数是表达式的问题，最终正确。

从上面来看，用宏实现简单的加法函数就这么麻烦，要考虑很多，但是人有 存在的意义： 将高频调用的小函数写成宏函数，可以提高效率，预处理阶段宏会替换，提高效率，不建立栈帧。

  • inline内联函数代替宏函数：
cpp 复制代码 
inline int Add(int a, int b)
{
	return a + b;
}

int main()
{
	int ret = Add(1, 2) * 3;
	cout << ret << endl;
	return 0;
}

正常定义函数，只需要前面加上关键字inline。使得函数象宏函数一样，不会再创建栈帧。

三、宏：nullptr

nullptr是一个宏，在传统的C头文件stddef.h中

cpp 复制代码 
#ifndef NULL
	#ifdef __cpulscpuls
		#define NULL 0
	#else
		#define NULL ((void*)0)
	#endif
#endif
  • C++中NULL可能被定义为字面常量0 ，或者C中被定义为无类型指针(void*)的常量 。不论如何定义，在使用空值的指针时，都会遇到麻烦，本想通过f(NULL)调用指针版本的f(int*)函数，但由于NULL被定义成0，调用了f(int x)，因此与程序的初衷相悖。f((void*)NULL);调用会报错。
  • C++11中引入nullptr，nullptr是⼀个特殊的关键字，是⼀种特殊类型的字面量，它可以转换成任意其他类型的指针类型 。使用nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，而不能被转换为整数类型。
cpp 复制代码 
#include<iostream>
using namespace std;

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

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

int main()
{
	f(0);//调用 f(int x)
	
	f(NULL);
	//想调用第2个函数，但是NULL被定义为0/(void*)0，导致调用了第1个函数

	f((int*)NULL);//调用 f(int* ptr)

	//f((void*)NULL);//void*不能隐式转换为int*，需要额外的类型转换

	f(nullptr);//调用 f(int* ptr)
	return 0;
}
cpp 复制代码 
// 不要这样写
int* p1 = NULL;
int* p2 = 0;

//应该这样写
int* p3 = nullptr;
f(nullptr);  // 明确调用指针版本的重载函数

总结

html 复制代码 
🍓 我是晨非辰Tong！若这篇技术干货帮你打通了学习中的卡点：
👀 【关注】跟我一起深耕技术领域，从基础到进阶，见证每一次成长
❤️ 【点赞】让优质内容被更多人看见，让知识传递更有力量
⭐ 【收藏】把核心知识点、实战技巧存好，需要时直接查、随时用
💬 【评论】分享你的经验或疑问（比如曾踩过的技术坑？），一起交流避坑
🗳️ 【投票】用你的选择助力社区内容方向，告诉大家哪个技术点最该重点拆解
技术之路难免有困惑，但同行的人会让前进更有方向～愿我们都能在自己专注的领域里，一步步靠近心中的技术目标！

结语：

引用解决了指针传参的繁琐与风险，提供了更安全的别名机制；内联函数在编译时权衡空间与时间，取代了宏函数的不可预测性；nullptr则以类型安全的方式终结了空指针的歧义。

它们共同展现了一个理念：在保持C语言效率同时，通过类型系统和语言机制提供更多安全保障。这正是C++能够在系统编程领域保持四十年前沿地位的重要原因。

【源码参考：https://gitee.com/tian-aochen/c-learning-record/tree/master/test_11.29_入门2/Basics】

相关推荐
喂我花生(๑•̀ㅂ•́)و✧5 小时前
网络中的一些基本概念
运维·服务器
拾光Ծ5 小时前
【Linux】深入理解“进程”：进程状态 -＞ Linux内核O(1)调度算法
linux·运维·服务器·算法
运维行者_5 小时前
PostgreSQL 十大性能问题及解决方案
运维·服务器·网络·数据库·postgresql·智能路由器·snmp
有Li5 小时前
基于深度学习的数字切片扫描仪无标记虚拟染色与人体组织分类|文献速递-文献分享
论文阅读·人工智能·深度学习·分类·医学生
东坡肘子5 小时前
挖掘“沉默的专家” -- 肘子的 Swift 周报 #114
人工智能·swiftui·swift
chase。5 小时前
【学习笔记】线性复杂度微分逆运动学：增广拉格朗日视角深度解析
人工智能·笔记·学习
七夜zippoe5 小时前
轻量模型推理性能优化实战：让AI在终端设备上“飞”起来
人工智能·知识蒸馏·轻量模型·量化感知
咚咚王者5 小时前
人工智能之数据分析 Pandas：第八章 数据可视化
人工智能·数据分析·pandas
草莓熊Lotso5 小时前
企业级 Git 分支管理模型实战：从 Git Flow 到 DevOps 落地
运维·服务器·开发语言·c++·人工智能·git·devops
热门推荐
01GitHub 镜像站点02【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）03安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）04UV安装并设置国内源05React CVE-2025-55182漏洞排查与修复指南06Linux下V2Ray安装配置指南07BongoCat - 跨平台键盘猫动画工具08智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践09从入门到实战：Gemini 3 使用指南速览10在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）