C++ 核心特性解析：引用、内联函数与 nullptr | 极客日志

C++算法

C++ 核心特性解析：引用、内联函数与 nullptr

C++ 引用提供变量别名机制避免拷贝开销，内联函数通过编译期展开消除调用栈帧提升性能，nullptr 关键字解决空指针类型歧义问题。三者共同优化代码效率与安全性，是现代 C++ 开发中必须掌握的基础特性。

暗影行者发布于 2026/3/27更新于 2026/4/251 浏览

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

{
    
    & j;
    cout << j << endl;
     ;
}

#include <iostream>
using namespace std;

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

#include <iostream>
using namespace std;

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

#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()
{
    // C 语言隐式转换
    int i = 0;
    double d = i;
    // 强制转换：整型、指针
    int p = (int)&i;
    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 种
#include <iostream>
#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); // 明确调用指针版本的重载函数