C++ 引用、内联函数与 nullptr 详解 | 极客日志

C++算法

C++ 引用、内联函数与 nullptr 详解

C++ 引用作为变量别名无需额外内存，常用于传参减少拷贝；内联函数在编译期展开调用以优化性能但受编译器限制；nullptr 关键字提供类型安全的空指针表示，避免 NULL 宏带来的重载歧义。三者共同提升代码效率与安全性。

DevStack发布于 2026/2/60 浏览

C++ 引用、内联函数与 nullptr 详解

引言

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

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

1.1 一览：引用的方方面面

概念及定义：

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

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

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

极客日志微信公众号二维码

更多推荐文章

相关免费在线工具

加密/解密文本
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。在线工具，加密/解密文本在线工具，online
Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online
Markdown转HTML
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。在线工具，Markdown转HTML在线工具，online
HTML转Markdown
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。在线工具，HTML转Markdown在线工具，online
JSON 压缩
通过删除不必要的空白来缩小和压缩JSON。在线工具，JSON 压缩在线工具，online

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

int main()
{
    int a[10];
    // 越界读：没事
    a[10];
    return 0;
}

int main()
{
    int a[10];
    // 越界写：有事
    a[11] = 1;
    a[15] = 1;
    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()
{
    // 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); // 明确调用指针版本的重载函数