C++ 核心三基石：引用、内联与 nullptr 深度解析 | 极客日志

C++算法

C++ 核心三基石：引用、内联与 nullptr 深度解析

C++ 引用作为变量别名无需额外内存，内联函数通过编译期展开消除调用开销，nullptr 提供类型安全的空指针表示。本文深入剖析三者底层机制、常见误区及最佳实践，涵盖传参优化、返回值陷阱、宏替代方案等实战细节，助力开发者提升代码性能与安全性。

dehua dong发布于 2026/3/22更新于 2026/5/86 浏览

C++ 核心三基石：引用、内联与 nullptr 深度解析

C++ 核心三基石：引用、内联与 nullptr 深度解析

C++ 的演进之路，是不断在性能与安全、灵活与严谨之间寻求平衡的艺术。理解引用、内联函数和 nullptr，不仅是掌握语法，更是洞察 C++ 设计哲学，书写更高效、更健壮代码的关键一步。

引用：C++ 前期重难点

概念及定义

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

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

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

引用的特性

引用在定义时必须初始化。
一个变量可以有多个引用。
引用一旦引用一个实体，再不能引用其他实体。

#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;
}

观察地址都是一个变量！

#include <iostream>
using namespace std;

int main() {
    // 未初始化引用
    int& j;
    cout << j << endl;
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int& b = a;
    // 再次引用其他变量相当于赋值
    int c = 20;
    b = c;
    cout << "b=" << b << endl;
    return 0;
}

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;
}

#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;
}

#include <iostream>
using namespace std;

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

int main() {
    int x = func();
    // func() += 1; // 报错
    return 0;
}

#include <iostream>
using namespace std;

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

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

#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;
}

#include <iostream>
using namespace std;

int main() {
    // const 对象
    const int a = 10;
    // 权限放大：不能
    // int& ra = a;
    // 权限缩小：可以
    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;
}

#include <iostream>
using namespace std;

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

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;
}

#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;
}

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;
}

// ADD 宏函数：第 1 种
#define ADD(int a,int b)return a+b;

#include <iostream>
using namespace std;
#define ADD(a,b) a + b

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

#include <iostream>
#define ADD(a, b)(a + b)

int main()

#include <iostream>
#define ADD(a, b)((a)+(b))

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

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

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

#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;
}

int* p1 = NULL;
int* p2 = 0;

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