C++ 中引用的概念、特性及使用详解 | 极客日志

C++算法

C++ 中引用的概念、特性及使用详解

C++ 中引用的概念、定义及特性，包括引用必须初始化、不可更改指向等规则。阐述了引用在传参和返回值中的应用优势，对比了指针与引用的区别，并讲解了 const 引用权限控制及临时对象处理。通过栈和链表实现示例，展示了引用如何简化代码并避免二级指针，同时指出了返回局部变量引用的风险及解决方案。

星星泡饭发布于 2026/3/30更新于 2026/4/131 浏览

C++ 中引用的概念、特性及使用详解

1. 引用

1.1 引用的概念和定义

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间（指针会开辟空间），它和它引用的变量共用同一块内存空间。比如：水浒传中林冲，外号豹子头

类型&引用别名=引用对象;

C++ 中为了避免引入太多的运算符，会复用 C 语言的一些符号，比如前面的<<和>>，这里引用也和取地址使用了同一个符号&。

如何区分取地址和引用呢？

&i->在变量之前是取地址

int&->在类型之后是引用

#include <iostream>
using namespace std;
int main() {
    int a = 0;
    // 引用：b 和 c 是 a 的别名
    int& b = a;
    int& c = a;
    // 也可以给别名 b 取别名，d 相当于还是 a 的别名
    int& d = b;
    // 这里取地址我们看到是一样的
    cout << &a << endl;
    cout << &b << endl;
    cout << &c << endl;
    cout << &d << endl;
    return 0;
}

在这里插入图片描述

#include <iostream>
using namespace std;
int main() {
    int a = 0;
    int& b = a;
    int& c = a;
    int& d = b;
    ++d; // ++d 就相当于 ++b，也就是 ++a
    cout << &a << endl; // 这里的&是取地址
    cout << &b << endl;
    cout << &c << endl;
    cout << &d << 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

int& b=a;//必须初始化 
int& c;//编译报错

int& b=a; 
int& c=a;

#include <iostream>
using namespace std;
int main() {
    int a = 10;
    int& b = a;
    int c = 20;
    // 这里并非让 b 引用 c，因为 C++ 引用不能改变指向
    // 这里是一个赋值
    b = c;
    cout << &a << endl;
    cout << &b << endl;
    cout << &c << endl;
    return 0;
}

#include <iostream>
using namespace std;
typedef int STDataType;
typedef struct Stack {
    STDataType* a;
    int top;
    int capacity;
} ST;
void STInit(ST& rs, int n = 4) {
    rs.a = (STDataType*)malloc(n * sizeof(STDataType));
    rs.top = 0;
    rs.capacity = n;
}
// 栈顶
void STPush(ST& rs, STDataType x) {
    assert(rs); // 满了，扩容
    if (rs.top == rs.capacity) {
        printf("扩容\n");
        int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
        STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity * sizeof(STDataType));
        if (tmp == NULL) {
            perror("realloc fail");
            return;
        }
        rs.a = tmp;
        rs.capacity = newcapacity;
    }
    rs.a[rs.top] = x;
    rs.top++;
}
// int STTop(ST& rs)
int& STTop(ST& rs) {
    assert(rs.top);
    return rs.a[rs.top];
}
int main() {
    // 调用全局的
    ST st1;
    STInit(st1);
    STPush(st1, 1);
    STPush(st1, 2);
    cout << STTop(st1) << endl;
    STTop(st1) += 10;
    cout << STTop(st1) << endl;
    return 0;
}

#include <iostream>
using namespace std;
typedef struct SeqList {
    int a[10];
    int size;
} SLT;
// 一些主要用 C 代码实现版本数据结构教材中，使用 C++ 引用替代指针传参，目的是简化程序，避开复杂的指针，但是很多同学没学过引用，导致一头雾水。
void SeqPushBack(SLT& sl, int x) {}
typedef struct ListNode {
    int val;
    struct ListNode* next;
} LTNode, *PNode;
// 指针变量也可以取别名，这里 LTNode*& phead 就是给指针变量取别名
// 这样就不需要用二级指针了，相对而言简化了程序
// void ListPushBack(LTNode** phead, int x)
// void ListPushBack(LTNode*& phead, int x)
void ListPushBack(PNode& phead, int x) {
    PNode newnode = (PNode)malloc(sizeof(LTNode));
    newnode->val = x;
    newnode->next = NULL;
    if (phead == NULL) {
        phead = newnode;
    } else {
        // ...
    }
}
int main() {
    PNode plist = NULL;
    ListPushBack(plist, 1);
    return 0;
}

void Swap(int& rx, int& ry) {
    int tmp = rx;
    rx = ry;
    ry = tmp;
}
void Swap(int* rx, int* ry) {
    int tmp = *rx;
    *rx = *ry;
    *ry = tmp;
}
// 这两个函数可以同时存在
int main() {
    int x = 0, y = 1;
    Swap(x, y);
    cout << x << " " << y << endl;
    Swap(&x, &y);
    cout << x << " " << y << endl;
    return 0;
}

// 指针
void Swap(int*& rx, int*& ry) {
    int* tmp = *rx;
    *rx = *ry;
    *ry = tmp;
}
void Swap(int** rx, int** ry) {
    int* tmp = *rx;
    *rx = *ry;
    *ry = tmp;
}
// 这两个函数不可以同时存在，会出现调用不明确的风险
int main() {
    int* x = &a;
    int* y = &b;
    Swap(x, y);
    cout << x << " " << y << endl;
    Swap(&x, &y);
    cout << x << " " << y << endl;
    return 0;
}

#include <iostream>
using namespace std;
typedef struct SeqList {
    int a[10];
    int size;
} SLT;
// 一些主要用 C 代码实现版本数据结构教材中，使用 C++ 引用替代指针传参，目的是简化程序，避开复杂的指针，但是很多同学没学过引用，导致一头雾水。
void SeqPushBack(SLT& sl, int x) {}
typedef struct ListNode {
    int val;
    struct ListNode* next;
} LTNode, *PNode;
// 相当于 typedef struct ListNode *PNode;(重命名)
// typedef struct ListNode LTNode;
// 指针变量也可以取别名，这里 LTNode*& phead 就是给指针变量取别名
// 这样就不需要用二级指针了，相对而言简化了程序
// void ListPushBack(LTNode** phead, int x)
// void ListPushBack(LTNode*& phead, int x)
void ListPushBack(PNode& phead, int x) {
    PNode newnode = (PNode)malloc(sizeof(LTNode));
    newnode->val = x;
    newnode->next = NULL;
    if (phead == NULL) {
        phead = newnode;
    } else {
        // 找到尾结点，newnode 链接到尾结点
    }
}
int main() {
    PNode plist = NULL;
    ListPushBack(plist, 1);
    return 0;
}

int func() {
    int ret = 0;
    return ret;
}
int main() {
    int a = func();
    return 0;
}

int& func() {
    int ret = 0;
    return ret;
} // 相当于我们返回了 ret 的别名
int main() {
    int a = func();
    cout << a << endl;
    return 0;
}

int& func1() {
    int ret = 0;
    return ret;
}
int& func2() {
    int y = 123;
    return y;
}
int main() {
    int& a = func1();
    cout << a << endl;
    func2();
    cout << a << endl;
    return 0;
}

int& func1() {
    static int ret = 0;
    return ret;
}
int& func2() {
    int y = 123;
    return y;
}
int main() {
    int& a = func1();
    cout << a << endl;
    func2();
    cout << a << endl;
    return 0;
}

int main() {
    const int a = 10;
    // 编译报错：error C2440: '初始化': 无法从'const int'转换为'int &'
    // 这里的引用是对 a 访问权限的放大
    // int& ra = a;
    // 这样才可以
    const int& ra = a;
    // 编译报错：error C3892: 'ra': 不能给常量赋值
    // ra++;
    // 这里的引用是对 b 访问权限的缩小，可以
    int b = 20;
    const int& rb = b;
    // 编译报错：error C3892: 'rb': 不能给常量赋值
    // rb++;
    return 0;
}

// 指针
const int* p1 = &a; // 报错：不能权限放大
int* p2 = p1; // 可以权限缩小
int* p3 = &e;
const int* p4 = p3;

// 如果不希望形参的改变影响实参，最好给形参加上 const
void func(const int& x) {}
int main() {
    int y = 0;
    func(y); // 形参加上 const 才会成功传参
    const int z = 1;
    func(z);
    func(1);
    return 0;
}

int i = 1;
double d = i;
int p = (int)&i;

#include <iostream>
using namespace std;
int main() {
    int a = 10;
    const int& ra = 30; // 编译报错：'初始化': 无法从'int'转换为'int &'
    int& rb = a * 3; // 可以
    const int& rb = a * 3;
    double d = 12.34; // 编译报错：'初始化': 无法从'double'转换为'int &'
    int& rd = d;
    const int& rd = d;
    return 0;
}