C++ 中引用与指针的区别详解-优快云博客

在C++中，引用和指针都是处理内存地址的重要机制，但它们在语法、语义和使用方式上有显著区别。下面通过代码示例详细讲解。

1. 基本概念对比

#include <iostream>
using namespace std;

int main() {
    int value = 10;
    
    // 指针声明和初始化
    int* ptr = &value;  // ptr指向value的地址
    
    // 引用声明和初始化
    int& ref = value;   // ref是value的别名
    
    cout << "原始值: " << value << endl;
    cout << "指针解引用: " << *ptr << endl;
    cout << "引用: " << ref << endl;
    
    return 0;
}

2. 主要区别详解

2.1 声明和初始化

void declarationDifference() {
    int x = 5;
    
    // 指针：可以声明时不初始化，可以重新指向其他变量
    int* ptr;        // 合法，但危险（野指针）
    ptr = &x;        // 指向x
    int y = 8;
    ptr = &y;        // 可以重新指向y
    
    // 引用：必须在声明时初始化，且不能重新绑定
    int& ref = x;    // 必须初始化
    // int& ref2;     // 错误：引用必须初始化
    // ref = y;       // 这是赋值操作，不是重新绑定
}

2.2 空值处理

void nullHandling() {
    // 指针可以为空
    int* ptr = nullptr;  // 合法
    if (ptr != nullptr) {
        cout << *ptr << endl;
    }
    
    // 引用不能为空
    // int& ref = nullptr;  // 错误：引用不能绑定到空值
    // int& ref;           // 错误：未初始化的引用
}

2.3 内存地址操作

void addressOperations() {
    int a = 10, b = 20;
    
    // 指针：可以进行算术运算
    int* ptr = &a;
    cout << "指针地址: " << ptr << endl;
    ptr++;  // 移动到下一个int位置
    cout << "指针++后地址: " << ptr << endl;
    
    // 引用：没有地址算术运算的概念
    int& ref = a;
    // ref++;        // 这是对a的值进行++，不是地址运算
    cout << "引用值: " << ref << endl;
}

2.4 多级间接访问

void multiLevelAccess() {
    int value = 100;
    
    // 指针：支持多级指针
    int* ptr = &value;
    int** pptr = &ptr;    // 指向指针的指针
    int*** ppptr = &pptr; // 三级指针
    
    cout << "值: " << ***ppptr << endl;
    
    // 引用：不支持多级引用
    int& ref = value;
    // int&& ref2 = ref;  // 错误：不存在引用的引用
    // 但可以通过指针创建对引用的引用
    int* ptr_to_ref = &ref;  // 指向引用实际就是指向原变量
}

3. 函数参数传递对比

3.1 指针作为参数

void modifyWithPointer(int* ptr) {
    if (ptr != nullptr) {
        *ptr = 999;  // 修改指针指向的值
    }
}

void pointerParameter() {
    int num = 10;
    cout << "修改前: " << num << endl;
    
    modifyWithPointer(&num);  // 传递地址
    cout << "修改后: " << num << endl;
    
    // 也可以传递空指针
    modifyWithPointer(nullptr);
}

3.2 引用作为参数

void modifyWithReference(int& ref) {
    ref = 888;  // 直接修改引用的值
}

void referenceParameter() {
    int num = 10;
    cout << "修改前: " << num << endl;
    
    modifyWithReference(num);  // 直接传递变量
    cout << "修改后: " << num << endl;
}

4. 数组操作对比

void arrayOperations() {
    int arr[5] = {1, 2, 3, 4, 5};
    
    // 指针：可以遍历数组
    int* ptr = arr;
    for (int i = 0; i < 5; i++) {
        cout << *(ptr + i) << " ";  // 指针算术
    }
    cout << endl;
    
    // 引用：可以创建数组的引用
    int (&arrRef)[5] = arr;  // 对数组的引用
    for (int i = 0; i < 5; i++) {
        cout << arrRef[i] << " ";  // 像数组一样使用
    }
    cout << endl;
}

5. 返回值的区别

// 返回指针：需要注意生命周期
int* createPointer() {
    static int value = 42;  // 静态变量确保生命周期
    return &value;
    // 危险做法：返回局部变量的地址
    // int local = 100;
    // return &local;  // 错误：局部变量会被销毁
}

// 返回引用：同样需要注意生命周期
int& createReference() {
    static int value = 24;
    return value;
    // 危险：返回局部变量的引用
    // int local = 200;
    // return local;   // 错误：局部变量会被销毁
}

void returnExamples() {
    int* ptr = createPointer();
    cout << "返回指针: " << *ptr << endl;
    
    int& ref = createReference();
    cout << "返回引用: " << ref << endl;
}

6. const限定符的使用

void constUsage() {
    int value = 50;
    
    // const指针
    const int* ptr1 = &value;  // 指向常量的指针
    // *ptr1 = 60;             // 错误：不能修改指向的值
    ptr1 = nullptr;            // 但可以改变指针本身
    
    int* const ptr2 = &value;  // 常量指针
    *ptr2 = 60;                // 可以修改指向的值
    // ptr2 = nullptr;         // 错误：不能改变指针本身
    
    // const引用
    const int& ref = value;    // 常量引用
    // ref = 70;               // 错误：不能通过引用修改值
    value = 70;                // 但原变量可以修改
}

7. 综合示例

#include <iostream>
using namespace std;

class Example {
private:
    int data;
public:
    Example(int d) : data(d) {}
    
    // 使用引用返回成员
    int& getDataRef() { return data; }
    
    // 使用指针返回成员地址
    int* getDataPtr() { return &data; }
};

int main() {
    // 基本使用对比
    int num = 100;
    
    // 指针使用
    int* p = &num;
    cout << "指针值: " << *p << endl;
    *p = 200;
    cout << "修改后num: " << num << endl;
    
    // 引用使用
    int& r = num;
    cout << "引用值: " << r << endl;
    r = 300;
    cout << "再次修改后num: " << num << endl;
    
    // 类成员访问
    Example obj(500);
    int& ref = obj.getDataRef();
    int* ptr = obj.getDataPtr();
    
    ref = 600;
    cout << "通过引用修改后: " << obj.getDataRef() << endl;
    
    *ptr = 700;
    cout << "通过指针修改后: " << obj.getDataRef() << endl;
    
    return 0;
}

总结

特性	指针	引用
初始化	可以不初始化	必须初始化
重新绑定	可以指向不同对象	不能重新绑定
空值	可以为nullptr	不能为空
地址运算	支持算术运算	不支持
多级间接	支持多级指针	不支持多级引用
语法简洁性	需要解引用(*)	直接使用
安全性	较低（可能为空或野指针）	较高