MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

C++引用与指针的区别及其应用

2022-07-054.6k 阅读

C++引用与指针的基本概念

在C++编程中，引用（reference）和指针（pointer）是两个重要的概念，它们都提供了一种间接访问变量的方式，但有着不同的特性和应用场景。

引用的定义与特点

引用是已存在变量的别名。一旦引用被初始化绑定到某个变量，它就一直指向该变量，不能再绑定到其他变量。引用在定义时必须初始化。例如：

int num = 10;
int &ref = num; // 定义一个引用ref，它是num的别名

这里，ref 就是 num 的别名，对 ref 的任何操作就相当于对 num 的操作。例如：

ref = 20;
std::cout << "num: " << num << std::endl; // 输出 num: 20

引用的主要特点包括：

  1. 必须初始化：定义引用时必须指定它所引用的对象，否则编译会报错。
  2. 不能重新绑定：一旦引用绑定到一个对象，就不能再绑定到其他对象。
  3. 不能为空：引用必须始终指向一个合法的对象，不存在空引用。

指针的定义与特点

指针是一个变量，其值为另一个变量的内存地址。通过指针，我们可以间接访问和修改该内存地址处存储的值。定义指针的方式如下：

int num = 10;
int *ptr = &num; // 定义一个指针ptr，指向num的地址

这里，ptr 存储了 num 的内存地址。我们可以通过解引用指针来访问所指向的值：

*ptr = 20;
std::cout << "num: " << num << std::endl; // 输出 num: 20

指针的主要特点包括：

  1. 可以为空：指针可以被初始化为 nullptr（C++11 引入），表示不指向任何对象。
int *ptr = nullptr;
  1. 可以重新赋值：指针可以在运行时指向不同的对象。
int num1 = 10;
int num2 = 20;
int *ptr = &num1;
ptr = &num2; // ptr 现在指向 num2
  1. 需要显式解引用：要访问指针所指向的值，需要使用 * 运算符进行解引用操作。

内存模型视角下的引用与指针

理解引用和指针在内存中的表示方式，有助于深入把握它们的本质区别。

引用的内存模型

在内存中，引用本身并不占用额外的空间用于存储地址信息。当我们定义一个引用时，编译器会在内部将对引用的操作转换为对其所引用对象的直接操作。例如：

int num = 10;
int &ref = num;

从内存角度看，ref 和 num 共享相同的存储位置，ref 只是 num 的一个别名，不存在单独存储 ref 指向 num 的地址的空间。

指针的内存模型

指针本身是一个变量，它占用一定的内存空间来存储所指向对象的地址。在32位系统中，指针通常占用4个字节；在64位系统中，指针通常占用8个字节。例如：

int num = 10;
int *ptr = &num;

这里，ptr 是一个指针变量，它存储了 num 的内存地址。ptr 本身在内存中有自己独立的存储位置，用于存放 num 的地址。

语法层面的区别

定义与初始化

引用在定义时必须初始化，而指针可以先定义后初始化，甚至可以初始化为 nullptr。

// 引用定义并初始化
int num1 = 10;
int &ref1 = num1; 

// 指针定义后初始化
int *ptr1;
int num2 = 20;
ptr1 = &num2; 

// 指针初始化为nullptr
int *ptr2 = nullptr;

运算符使用

引用使用时不需要显式的解引用运算符，对引用的操作就直接作用于所引用的对象。而指针需要使用 * 运算符进行解引用以访问所指向的值，使用 & 运算符获取变量的地址。

int num = 10;
int &ref = num;
int *ptr = &num;

ref = 20; // 直接修改引用所指向的值
std::cout << "num through ref: " << ref << std::endl; 

*ptr = 30; // 通过解引用指针修改所指向的值
std::cout << "num through ptr: " << *ptr << std::endl; 

std::cout << "Address of num: " << &num << std::endl; 
std::cout << "Address stored in ptr: " << ptr << std::endl;

数组与指针

在C++ 中，数组名在很多情况下会被隐式转换为指向数组首元素的指针。但是，不能定义数组的引用，只能定义指向数组的指针。

int arr[5] = {1, 2, 3, 4, 5};

// 定义指向数组的指针
int (*ptrToArr)[5] = &arr; 

// 下面的定义是错误的，不能定义数组的引用
// int (&refToArr)[5] = arr;

语义与应用场景的区别

语义上的区别

引用强调的是别名关系，它与所引用的对象是一体的，操作引用就如同操作对象本身。而指针更强调的是地址的概念，它通过地址间接访问对象，指针可以在不同对象之间切换。

例如，在函数参数传递中，如果使用引用传递参数，函数内部对参数的修改会直接影响到调用者的实参，因为引用就是实参的别名。而指针传递参数时，虽然也能通过解引用修改实参，但语义上更强调通过地址的间接访问。

应用场景的区别

  1. 引用的应用场景
    • 函数参数传递：当我们希望函数内部能够修改调用者传入的实参，同时又不想增加额外的指针解引用操作的复杂性时，通常使用引用传递。例如，在交换两个数的函数中：
void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int num1 = 10;
    int num2 = 20;
    swap(num1, num2);
    std::cout << "num1: " << num1 << ", num2: " << num2 << std::endl; 
    return 0;
}

- **返回对象**：当函数需要返回一个对象，并且希望避免对象拷贝时，可以返回对象的引用。例如，在单例模式的实现中：

class Singleton {
private:
    static Singleton instance;
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton& getInstance() {
        return instance;
    }
};

Singleton Singleton::instance;

int main() {
    Singleton &singleton1 = Singleton::getInstance();
    Singleton &singleton2 = Singleton::getInstance();
    return 0;
}
  1. 指针的应用场景
    • 动态内存分配：在需要动态分配内存时，通常使用指针。例如，使用 new 运算符分配内存后，会返回一个指向所分配内存的指针。
int *dynamicNum = new int(10);
delete dynamicNum; 

- **链表、树等数据结构**：这些数据结构的节点通常包含指针成员，用于连接不同的节点。例如，链表节点的定义：

struct ListNode {
    int data;
    ListNode *next;
    ListNode(int value) : data(value), next(nullptr) {}
};

- **实现多态**：在C++ 中，通过基类指针指向派生类对象来实现多态。例如：

class Animal {
public:
    virtual void speak() {
        std::cout << "Animal speaks" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Dog barks" << std::endl;
    }
};

int main() {
    Animal *animalPtr = new Dog();
    animalPtr->speak(); 
    delete animalPtr;
    return 0;
}

性能考虑

引用的性能

由于引用在内部实现上并不占用额外的空间用于存储地址，并且对引用的操作直接转换为对所引用对象的操作，所以在性能上，使用引用通常没有额外的开销。特别是在函数参数传递和返回对象时，如果使用引用传递和返回，能够避免对象的拷贝构造和析构，从而提高性能。

指针的性能

指针本身占用一定的内存空间来存储地址，在访问指针所指向的值时，需要进行一次间接寻址（解引用操作）。这在一定程度上会增加访问的开销。然而，在动态内存分配和复杂数据结构的实现中，指针的灵活性是不可替代的，虽然存在一定的性能开销，但在合理使用的情况下，对整体性能的影响可以接受。

例如，在遍历一个链表时，每次通过指针访问下一个节点需要进行解引用操作，但链表这种数据结构的灵活性决定了指针是实现它的必要工具。

错误处理与安全性

引用的错误处理与安全性

由于引用不能为空且一旦绑定就不能重新绑定，所以在使用引用时，只要引用被正确初始化，就不会出现空引用或野引用（指向已释放内存的引用）的问题。这使得代码在使用引用时相对更安全，减少了因指针操作不当而导致的内存错误。

例如，在函数参数传递中，如果使用引用传递，调用者必须传入一个有效的对象，否则编译就会出错。

指针的错误处理与安全性

指针可以为空，并且可以在运行时改变指向，这使得指针在使用时需要更加小心。如果指针为空或者指向已释放的内存（野指针），对其进行解引用操作会导致程序崩溃或未定义行为。

例如，以下代码中就存在野指针的问题：

int *ptr = new int(10);
delete ptr;
// ptr 现在是野指针
*ptr = 20; // 这会导致未定义行为

为了避免指针相关的错误，在C++11 中引入了智能指针（如 std::unique_ptr、std::shared_ptr 和 std::weak_ptr），它们能够自动管理所指向对象的生命周期，减少野指针和内存泄漏的风险。

总结引用与指针的区别在实际编程中的影响

在实际的C++编程中，理解引用和指针的区别对于编写高效、安全和易于维护的代码至关重要。

如果我们希望强调对象的别名关系，并且确保代码的简洁性和安全性，同时避免空引用或重新绑定的问题，那么引用是一个很好的选择，尤其在函数参数传递和返回对象的场景中。

而当我们需要动态分配内存、实现复杂的数据结构或者利用多态特性时，指针的灵活性则是不可或缺的。不过，在使用指针时，我们需要更加谨慎地处理空指针、野指针和内存管理等问题，以确保程序的稳定性和安全性。

在很多情况下，我们可能会在同一个程序中同时使用引用和指针，根据不同的需求和场景来选择最合适的工具。通过合理运用引用和指针，我们能够充分发挥C++语言的强大功能，编写出高质量的代码。例如，在一个大型的面向对象程序中，可能会在类的成员函数参数传递中使用引用，以提高性能和代码的可读性；而在实现一些数据结构如树、图等时，会使用指针来构建节点之间的连接关系。

总之，深入理解C++引用与指针的区别及其应用场景，是每个C++程序员必备的技能，它将有助于我们编写出更健壮、高效且易于维护的代码。