指针与引用20题

1.指针和引用有什么区别？它们在C++中的使用场景有何异同？

指针和引用是C++中两种常用的数据类型，它们有以下区别和使用场景的异同点：

• 定义方式：指针是一个变量，存储着另一个对象的内存地址，使用*来声明和操作指针；而引用是对象的别名，通过使用&来声明和操作引用。

• 空值：指针可以为空值（null），即不指向任何对象；而引用必须在初始化时绑定到一个有效的对象，不能为空。

• 可修改性：指针可以被重新赋值，可以改变所指向的对象；而引用一旦绑定到了一个对象后就无法再改变绑定关系。

• 使用限制：指针可以有空悬（dangling）指针问题，在所指向的对象释放后依然保留该地址；而引用始终与某个有效的对象关联，并且不会出现空悬引用问题。

• 操作语法：对于指针需要通过解引用（*）操作来访问或修改所指向的对象；而对于引用则直接使用原始变量名进行操作。

在使用场景上：

• 指针通常用于动态内存分配、数组遍历、传递参数等需要灵活处理内存或者需要传递地址信息的情况下。

• 引用通常用于函数参数传递、返回值、遍历容器等情况下，提供了更简洁和直观的语法。

2.什么是空指针和野指针？如何避免它们的出现？

• 空指针是指没有指向任何有效对象的指针。在C++中，可以使用特殊值nullptr表示空指针。

• 野指针是指未被正确初始化或者已经释放的指针，它可能包含一个无效的内存地址，导致访问到不属于自己的内存区域。

为了避免空指针和野指针的出现，可以考虑以下几点：

• 初始化：在定义指针变量时，立即将其初始化为合理的初始值或者将其设为nullptr，这样可以确保不会产生随机值导致野指针问题。

• 空检查：在使用指针之前进行空检查，避免对空指针进行解引用操作。可以通过条件判断语句（例如if(ptr != nullptr)）或者C++11引入的安全访问运算符（->）来进行空检查。

• 合理释放：在动态分配内存后要记得及时释放，并将该指针置为空。同时，在释放后不再使用该指针避免产生野指针。

• 尽量使用引用：相比于裸指针，尽可能地使用引用作为函数参数、返回值等传递和绑定对象。引用更加安全且不会出现空悬和野性问题。

• 使用智能指针：C++提供了智能指针（如std::shared_ptr和std::unique_ptr），它们可以自动管理内存，避免手动释放和潜在的空悬指针问题。

3.如何声明和初始化指针和引用？

在C++中，声明和初始化指针和引用有以下几种方式：

(1)指针的声明和初始化：

int* ptr; // 声明一个指向整型的指针变量
int* ptr = nullptr; // C++11后可使用nullptr初始化为空指针
int* ptr = new int; // 动态分配内存并初始化为默认值（未初始化）
int* ptr = new int(10); // 动态分配内存并初始化为给定值
int* ptr = &variable; // 将指针指向已存在的变量

 (2)引用的声明和初始化：

int variable = 10;
int& ref = variable; // 声明一个整型引用，并将其绑定到已存在的变量

需要注意的是，引用一旦被绑定到某个对象后，就无法再更改它所绑定的对象。而指针可以重新赋值来指向不同的对象。

此外，对于智能指针（如std::shared_ptr和std::unique_ptr），可以通过以下方式进行声明和初始化：

#include <memory>

std::shared_ptr<int> sptr = std::make_shared<int>(); // 使用make_shared动态分配内存并进行初始化

std::unique_ptr<int> uptr(new int()); // 使用new关键字动态分配内存并进行初始化

// 使用reset方法重新赋值或释放智能指针所管理的资源
sptr.reset();
uptr.reset();

 

4.指针和引用在函数参数传递中有何区别？为什么要使用引用传递而不是指针传递或值传递？

• 语法上的区别：指针使用*来声明和解引用，而引用使用&进行声明。

• 空值（null）处理：指针可以为空指针，即指向空内存地址或不指向任何对象。而引用必须始终绑定到一个已存在的对象上，不能为null。

• 重新赋值：指针可以被重新赋值来指向其他对象，而引用一旦绑定后就无法更改其所绑定的对象。

为什么要使用引用传递而不是指针传递或值传递呢？这是因为引用传递具有以下优点：

• 效率高：与值传递相比，通过引用传递参数避免了创建副本的开销。对于大型数据结构或类对象，这种开销可能会很大。

• 直观性强：使用引用作为函数参数时，代码可读性更好。调用函数时无需显式地取址和解引用操作。

• 修改实参：通过修改引用参数，可以直接修改原始变量的值。而使用指针传递时，需要通过解引用来修改实参，并且在调用函数时需要明确取地址。

5.如何在函数中返回指向局部变量的指针或引用？会有什么问题？

在函数中返回指向局部变量的指针或引用是不安全的，因为局部变量在函数执行完毕后会被销毁。返回一个指向已经销毁的局部变量的指针或引用将导致未定义行为。

当函数结束时，其内部的局部变量存储在栈上，并且栈帧会被释放。如果试图通过指针或引用访问已经销毁的对象，可能会导致悬空指针、野指针等问题，这些问题往往是难以调试和预测的。

为了避免这种问题，可以采取以下解决方案：

• 返回拷贝：将局部变量拷贝到堆上分配的对象中，并返回该对象的指针或引用。这样可以确保返回值是有效的，并且不会受到局部变量销毁的影响。

• 动态内存分配：如果需要返回动态创建的对象，则可以使用new关键字在堆上创建对象，并返回对应的指针。但要注意，在使用完之后需要手动释放内存以避免内存泄漏。

• 使用静态或全局变量：静态或全局变量具有静态生命周期，它们存在于整个程序运行期间。虽然可以返回其地址作为指针或引用，但需谨慎使用，因为可能会引入不必要的全局状态和线程安全问题。

6.什么是常量指针和指向常量的指针？它们之间有何区别？

常量指针（const pointer）和指向常量的指针（pointer to const）是两种不同的概念。

常量指针是指一旦初始化，就不能再改变所指向的对象地址的指针。也就是说，它的值（即存储的地址）是不可修改的，但可以通过它来修改所指向对象的值。例如：

int x = 5;
int* const ptr = &x; // 常量指针，ptr不能再指向其他地址
*ptr = 10;          // 修改所指向对象的值为10

 而指向常量的指针则是指其所指向对象是不可修改的，但本身可以改变所指向对象地址。也就是说，它能够修改自己存储的地址，但不能通过它来修改所指向对象的值。例如：

const int x = 5;
const int* ptr = &x; // 指向常量的指针，ptr可以改变自己存储的地址
ptr = &y;           // 修改所存储地址为y的地址

7.什么是常量引用和引用常量？它们之间有何区别？

常量引用（const reference）指的是通过引用来绑定到一个对象，并且该对象不能被修改。通过常量引用，我们可以读取所引用的对象，但不能对其进行修改。它使用 const 关键字进行声明，表示对所引用的对象的只读访问。例如：

int x = 5;
const int& ref = x; // 常量引用，ref绑定到x，并且不能通过ref修改x的值

 引用常量（reference to const）指的是通过引用来绑定到一个不可修改的对象。通过引用常量，我们既可以读取所引用的对象，也确保不会对其进行修改。它将 const 关键字放在类型名前面表示所引用对象为常量。例如：

const int x = 5;
const int& ref = x; // 引用常量，ref绑定到x，并且不能通过ref修改x的值

 区别：

• 常量引用允许原始变量被修改，但限制了通过该引用对原始变量进行更改；

• 引用常量旨在保护原始变量的值不被修改。

8.为什么要使用const关键字来限制指针或引用的修改操作？

• 防止意外修改：在某些情况下，我们可能希望将某个变量或对象声明为只读，不希望它被修改。通过使用const关键字，可以确保在编译时期对这些变量或对象进行保护，避免了意外的修改。

• 安全性考虑：有时候我们需要将变量传递给函数或方法，并且希望这些函数或方法不会修改传入的变量。通过将参数声明为const指针或引用，可以确保函数内部不会对其进行修改，提高代码的安全性。

• 优化编译器优化：编译器可以利用const关键字来进行一些优化。例如，在某些情况下，如果一个值被声明为常量，则编译器可以直接将该值嵌入到代码中，而不是每次访问时都要从内存中加载。

• 接口规范：在定义类的接口时，使用const关键字可以清晰地表达出某个成员函数不会对对象状态进行更改。

9.引用可以为空吗？为什么？

引用在定义时必须初始化，并且不能为空。这是因为引用在语义上表示对某个对象的别名，它始终与某个已存在的对象相绑定。所以，在定义引用时，需要将其绑定到一个有效的对象。

如果试图将引用设置为空或未初始化，会导致编译错误。因为引用在内部实现上通常被视为指针常量，即一个指向对象的常量指针。而空指针是指向内存中地址为0的位置，不代表任何有效对象。

同时，在程序中使用一个空引用也没有意义，因为它无法通过引用来访问或修改任何有效的数据。因此，在定义和使用引用时，必须确保它总是与有效的对象相关联。

10.指针数组与数组指针之间有何区别？

• 指针数组（Pointer Array）：指针数组是一个数组，其中的每个元素都是指针。这意味着它存储了多个指针变量，并且每个指针可以指向不同类型或相同类型的数据。例如，int* arr[5] 表示一个包含 5 个元素的指针数组，每个元素都是 int 类型的指针。

• 数组指针（Array Pointer）：数组指针是一个指向数组的指针，它存储了数组的首地址。通过对该指针进行解引用操作，可以访问到整个数组。例如，int (*ptr)[5] 表示一个指向包含 5 个元素的 int 类型数组的指针。

区别在于：

• 内容：在使用时，对于指针数组，我们可以通过索引来访问或修改每个元素所存储的地址；而对于数组指针，则需要使用解引用运算符 * 来访问整个数组。

• 存储方式：在内存中，一个指针数组实际上是按顺序存放多个独立的、具有相同类型但可能不同大小的内存块；而一个数组指针则直接保存整个连续内存块的起始地址。

11.在C++中，new和malloc之间有什么区别？delete和free呢？

• 语法：new 是一个运算符，而 malloc 是一个函数。使用 new 时可以直接调用构造函数进行对象初始化，而 malloc 只能分配一块原始的内存空间。

• 类型安全：new 运算符是类型安全的，在分配内存时会自动根据类型进行大小计算，并返回指定类型的指针。而 malloc 返回 void* 指针，需要手动转换为相应类型。

• 内存管理：new 运算符不仅会分配内存，还会调用构造函数初始化对象；而 malloc 只是简单地分配一块内存空间，并没有进行初始化。

• 异常处理：new 在发生内存不足等异常时，可以抛出 std::bad_alloc 异常；而 malloc 则无法处理异常情况。

对应的释放操作 delete 和 free 的区别如下：

• 语法：delete 是一个运算符，free 是一个函数。使用 delete 时只需提供要删除的对象指针即可；而 free 需要传入要释放的指针作为参数。

• 对象析构函数调用：delete 运算符会先调用对象的析构函数销毁对象后再释放内存；free 函数只是简单地释放内存，不会调用任何析构函数。

12.如何处理内存泄漏问题，在程序中删除动态分配的内存时需要注意哪些问题？

• 确保每次使用 new、malloc 或类似函数分配内存后，都要相应地使用 delete、free 或类似函数释放内存。确保分配和释放操作成对出现。

• 在对象不再需要时，及时释放相关的动态分配内存。避免在循环或长时间运行的程序中累积大量未释放的内存。

• 对于容器类如数组、链表等，在删除对象时也要逐个删除其中包含的动态分配内存，并在删除完最后一个对象后再释放容器本身。

• 避免将同一个指针多次传递给 delete、free 函数，这可能导致重复释放或访问已经释放的内存。

• 注意析构函数的正确实现。如果某个类在析构时应该释放动态分配的资源，记得在析构函数中进行相应的清理工作。

• 使用智能指针（如 std::shared_ptr、std::unique_ptr）来管理动态分配的对象，可以自动进行资源回收，减少手动处理错误导致的内存泄漏问题。

• 使用工具和技术来检测和调试内存泄漏问题，比如使用静态代码分析工具、内存分析工具或编写自己的测试代码。

13.C++中的智能指针是什么？如何避免手动管理内存的麻烦？

C++中的智能指针是一种可以自动管理动态分配内存的指针类型。它们提供了更高层次的抽象，使得内存资源的管理更加方便和安全。

C++标准库提供了两个主要的智能指针类：std::shared_ptr 和 std::unique_ptr。

std::shared_ptr：多个 shared_ptr 可以共享同一个对象，并且会自动在最后一个使用它的 shared_ptr 销毁时释放内存。可以通过构造函数、make_shared 函数或赋值操作符创建 shared_ptr。示例：

std::shared_ptr<int> p1 = std::make_shared<int>(42);
std::shared_ptr<int> p2 = p1;  // 共享所有权

std::unique_ptr：独占所有权的智能指针，不允许多个 unique_ptr 指向同一个对象。当 unique_ptr 超出作用域时，会自动调用析构函数释放内存。示例：

std::unique_ptr<int> p1 = std::make_unique<int>(42);
std::unique_ptr<int> p2 = std::move(p1);  // 转移所有权给p2

使用智能指针可以避免手动管理内存带来的麻烦和潜在错误，例如忘记释放内存或多次释放相同的内存。由于智能指针会在合适的时机自动调用析构函数释放内存，大大减轻了开发者的负担。

然而，仍需注意避免循环引用问题。当两个或多个对象相互持有对方的 shared_ptr，可能导致内存泄漏。此时，可以使用 std::weak_ptr 来解决循环引用问题。

14.什么是空引用？在使用引用时如何避免出现空引用？

空引用是指引用一个未初始化的对象或已经被销毁的对象。在使用空引用时，会导致未定义行为，可能导致程序崩溃或产生不可预料的结果。

为了避免出现空引用，在使用引用之前，应该确保它所引用的对象是有效的。有几种方式可以避免出现空引用：

初始化时赋予有效值：在定义引用变量时，确保它被赋予一个有效的对象。例如：

int value = 42;
int& ref = value; // 引用有效对象value

使用指针和条件判断：如果不能确保引用始终指向有效对象，可以使用指针，并通过条件判断来避免操作空指针。例如：

int* ptr = nullptr; // 初始化为空指针
if (ptr != nullptr) {
    *ptr = 42; // 避免操作空指针
}

异常处理：在某些情况下，如果无法提供有效的对象给引用，可以考虑使用异常处理机制来捕获并处理潜在的错误。

try {
    int& ref = getReference(); // 获取可能为空的引用
    // 使用ref进行操作
} catch (...) {
    // 处理异常情况
}

15.引用作为函数返回值时需要注意哪些问题？可以返回局部变量的引用吗？

• 避免返回指向已销毁的局部变量的引用：局部变量在函数结束后会被销毁，如果返回一个指向局部变量的引用，那么在引用被使用时就会出现未定义行为。因此，不应该返回指向局部变量的引用。

• 返回静态成员或全局变量的引用是安全的：静态成员和全局变量在程序生命周期内都存在，可以安全地将其引用作为函数返回值。

• 返回类成员或动态分配对象的引用需要谨慎：如果函数返回一个类成员或动态分配的对象的引用，需要确保这些对象在函数调用结束之前仍然有效。一般来说，最好避免返回类成员或动态分配对象的引用，而是选择其他方式（如返回指针、智能指针或副本）来传递对象。

• 引用作为函数返回值可以实现链式调用：使用引用作为函数返回值时，可以实现链式调用，在连续多次调用函数时简化代码书写。

16.如何通过指针修改传递给函数的值？

• 在函数声明中使用指针参数：将要修改的变量的地址作为参数传递给函数。例如，如果要修改一个整数变量的值，可以声明函数为 void modifyValue(int *ptr)。

• 在函数内部通过解引用操作符 * 访问和修改变量的值：在函数内部使用解引用操作符 * 可以获取指针所指向的变量，并对其进行修改。例如，可以使用 *ptr = newValue 来修改变量的值。

• 通过传递实际参数调用函数：在调用函数时，将需要修改的变量的地址作为实际参数传递给函数。例如，可以调用 modifyValue(&myVariable) 来将 myVariable 的地址传递给 modifyValue 函数。

以下是一个示例代码：

#include <iostream>

void modifyValue(int *ptr) {
    *ptr = 42; // 修改指针所指向的值
}

int main() {
    int myVariable = 10;
    std::cout << "Before modification: " << myVariable << std::endl;
    
    modifyValue(&myVariable); // 通过指针修改值
    
    std::cout << "After modification: " << myVariable << std::endl;
    
    return 0;
}

输出结果：

Before modification: 10
After modification: 42

注意：在使用指针来修改传递给函数的值时，请确保传递给函数的指针是有效的，即指向正确的变量。同时也要注意避免空指针和悬垂指针的问题。

17.什么是指针算术运算？它在什么情况下有用？

指针算术运算是指对指针进行数学计算的操作。在C++中，可以对指针进行加法、减法、递增和递减等算术运算。

指针算术运算在以下情况下非常有用：

• 数组遍历：通过使用指针算术运算，可以方便地遍历数组元素。例如，通过递增指向数组的指针，可以顺序访问数组的每个元素。

• 字符串操作：字符串通常以字符数组的形式表示，在处理字符串时，使用指针算术运算可以更方便地定位、移动和修改字符串中的字符。

• 内存管理：在动态内存分配和释放过程中，使用指针来跟踪内存块的起始位置，并通过指针算术运算来管理内存块。

• 数据结构：某些数据结构（如链表）需要在节点之间建立关联关系，使用指针来表示节点并进行相应的链接和跳转操作。

• 优化性能：有时候通过使用指针和指针算术运算可以提高代码执行效率，尤其是对于大规模数据结构或连续内存区域的操作。

18.C++中的虚函数表（vtable）和虚函数指针有何关系？如何使用它们实现多态性？

在C++中，虚函数表（vtable）和虚函数指针是实现多态性的关键组成部分。

虚函数表是一个特殊的数据结构，用于存储包含类的虚函数的地址。每个具有至少一个虚函数的类都有其自己的虚函数表。虚函数表以一种规范化的方式组织了所有虚函数的地址，并且每个类只有一个对应的虚函数表。

而每个对象实例（或者说类的对象）在内存中都有一个隐藏的指向该类对应虚函数表的指针，通常称为虚函数指针。这个指针被添加到对象布局中作为额外开销。

通过使用这种机制，当调用基类或派生类对象上声明为虚函数的方法时，会根据对象所属类来查找正确的虚函数表，并从相应位置获取正确的虚函数地址进行调用。这就实现了多态性，即可以通过基类类型调用派生类特定实现版本的方法。

使用它们实现多态性通常需要以下步骤：

• 在基类中声明一个或多个虚函数。

• 派生类继承基类并覆盖其中一个或多个相同名称和参数列表的虚函数。

• 将需要使用多态性效果时将基类指针或引用指向派生类对象。

• 通过基类指针或引用调用虚函数，编译器会根据实际对象的类型查找正确的虚函数表，并调用相应的派生类实现。

这样，无论基类指针或引用指向哪个具体的派生类对象，都可以在运行时动态地选择正确的虚函数进行调用，实现了多态性。

19.在多线程环境中，指针和引用的使用可能会导致什么问题？如何解决这些问题？

• 竞态条件（Race Condition）：如果多个线程同时读写共享资源，并且其中至少有一个是写操作，就会发生竞态条件。这可能导致未定义的行为和数据损坏。

• 悬垂指针（Dangling Pointer）：当一个指针指向已经被释放的内存或者无效的对象时，它就成为悬垂指针。如果其他线程尝试访问该悬垂指针，将导致未定义的行为。

• 数据竞争（Data Race）：当多个线程同时读写共享数据时，没有适当的同步机制保护下，会发生数据竞争。这可能导致不一致或错误的结果。

为了解决这些问题，在多线程环境中可以采取以下措施：

• 使用互斥锁（Mutex）或其他同步原语来保护共享资源的访问。通过确保同一时间只有一个线程能够修改共享资源，避免了竞态条件。

• 使用智能指针（如std::shared_ptr、std::unique_ptr）来管理动态分配的内存。智能指针提供了自动化内存管理，避免了悬垂指针和内存泄漏的问题。

• 使用原子操作（Atomic Operations）来保证对共享数据的原子性操作，避免数据竞争。原子操作提供了一种无锁的线程安全机制，能够确保特定操作以原子方式执行。

• 使用线程局部存储（Thread-Local Storage）来在每个线程中维护独立的变量副本。这样可以避免多个线程之间对同一变量进行竞争访问。

• 设计良好的并发数据结构和算法，例如锁粒度细化、无锁数据结构等，以减少对共享资源的频繁访问和修改。

20.指针和引用在数据结构中的常见应用有哪些？

• 链表（Linked List）：链表是一种常见的动态数据结构，在链表中使用指针来连接不同节点，以便进行遍历、插入和删除操作。

• 树（Tree）：树结构也经常使用指针来表示节点之间的关系。例如二叉树、红黑树等都使用指针来链接左右子节点或兄弟节点。

• 图（Graph）：图是由顶点和边组成的一种非线性数据结构。在图中使用指针或引用可以表示顶点之间的连接关系。

• 堆（Heap）：堆是一种基于完全二叉树实现的优先队列。在堆中使用指针可以方便地进行元素插入、删除和调整等操作。

• 队列（Queue）和栈（Stack）：队列和栈通常采用数组或链表作为底层实现，而指针则被广泛用于链接各个元素。

• 图形结构：在计算机图形学中，使用指针或引用来表示物体之间的相对位置、父子关系等信息，如场景图、骨骼动画等。

<节选自 微信公众号：深入浅出cpp>