C++面试八股文：智能指针

一、了解哪些智能指针？

回答：智能指针是用于管理动态分配的内存，行为类似于指针，但又具有自动管理内存的能力，所以称为智能指针。

首先说一下 auto_ptr和unique_ptr，它们都是独占式指针，同一时间只能有一个指针拥有所有权。
auto_ptr是c++98引入，unique_ptr是c++11引入，替代了auto_ptr。

auto_ptr在设计上存在一些问题：
1、所有权转移的隐式语义（容易引发意外行为）
问题本质：auto_ptr 的拷贝构造函数和赋值运算符会转移资源的所有权，导致原指针变为 nullptr。这种隐式所有权转移在代码中难以察觉，容易引发逻辑错误。
对比 unique_ptr：C++11 的 unique_ptr 通过禁用拷贝构造函数（仅允许显式移动语义）明确所有权转移的意图，避免隐式错误。
2、与 STL 容器不兼容
问题本质：STL 容器（如 vector、list）要求元素是可拷贝且行为可预测的。而 auto_ptr 在拷贝时转移所有权，会导致容器内部元素意外失效。
对比 unique_ptr：unique_ptr 不可拷贝，但支持移动语义，可与 C++11 后的容器安全配合。
3、无法正确处理数组
因为它内部使用delete而不是delete[]，所以如果用auto_ptr来管理数组会导致内存泄漏。

shared_ptr和weak_ptr：
shared_ptr使用了引用计数（use count）技术，当复制个shared_ptr对象时，被管理的资源并没有被复制，而是增加了引用计数。当析构一个shared_ptr对象时，也不会直接释放被管理的的资源，而是将引用计数减一。当引用计数为0时，才会真正的释放资源。shared_ptr可以方便的共享资源而不必创建多个资源。

weak_ptr则是一种弱引用，指向shared_ptr所管理的对象;
weak_ptr可以解决shared_ptr所持有的资源循环引用问题。weak_ptr在指向shared_ptr时，并不会增加shared_ptr的引用计数。

weak_ptr常用于实现观察者模式、缓存机制等场景，在这些场景中，我们需要观察一个对象，但又不想影响其生命周期。

shared_ptr VS unique_ptr

尽可能用unique_ptr
shared_ptr应该仅在绝对需要共享时使用
避免使用任何其他指针，如weakptr、raw指针等。

从技术上讲，所有unique_ptr都可以被shared_ptr替换而不会出现编译错误，但我们仍然使用unique_ptr，原因如下：

unique_ptr具有与C++原始指针“几乎”相同的效率，包括大小分配、引用/取消引用（假设没有自定义构造函数）。
unique_ptr明确了对象的所有权和生存时间。
shared_ptr的大小是原始指针的两倍，堆栈更大。
最重要的是，shared_ptr需要维护引用计数，并且该操作必须是原子的（即线程安全的），这与unique_ptr相比增加了恒定的开销。

因此，我们不应该仅仅因为方便而使用shared_ptr：对于shared_pcr的每次使用，我们都需要明确解释为什么这应该是一个共享指针，以及需要共享这个对象的模块/函数是什么。

避免使用所有其他指针，如weak_ptr或raw指针，因为在大多数情况下，它们可以被unique_ptr/shared_ptr替换。然而，显然也有例外，例如，所有QT应用程序都建议使用原始指针来管理UI组件。

常见面试问题

智能指针有哪些种类，它们各自的特点和适用场景是什么？

unique_ptr（独占指针）
特点：

独占所有权，同一时间只能有一个 unique_ptr 指向资源。

禁止拷贝，支持移动语义（通过 std::move 转移所有权）。

轻量级，无额外内存开销。

shared_ptr（共享指针）
特点：

共享所有权，通过引用计数管理资源生命周期。

支持拷贝和赋值，引用计数为 0 时自动释放资源。

控制块包含引用计数和删除器，有一定内存开销。

适用场景：

多个对象需要共享同一资源（如缓存、观察者模式）。

需要跨作用域共享资源。

weak_ptr（弱指针）
特点：

不增加引用计数，用于观测 shared_ptr 管理的资源。

需通过 lock() 转换为 shared_ptr 才能访问资源。

适用场景：

解决 shared_ptr 循环引用问题。

缓存或观察者模式中避免持有资源所有权。

智能指针是如何实现自动内存管理的，背后的原理是什么？

核心机制：基于 RAII（Resource Acquisition Is Initialization）设计模式。

资源获取即初始化：在构造函数中分配资源，在析构函数中释放资源。

{
    std::unique_ptr<int> p(new int(42)); // 构造时分配内存
    // 使用 p
} // 离开作用域时，p 析构并自动调用 delete 释放内存

shared_ptr 是如何实现引用计数的，引用计数在多线程环境下有什么问题，如何解决？

引用计数的修改需保证原子性，否则多线程竞争导致计数错误。
使用原子操作（std::atomic）管理引用计数。

注意：shared_ptr 的引用计数本身是线程安全的，但指向的资源需额外同步。

unique_ptr 为什么不支持拷贝和赋值操作，它是如何实现资源的独占式管理的？

禁止拷贝和赋值：

通过删除拷贝构造函数和拷贝赋值运算符实现：

unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;

支持移动语义：

允许通过移动构造函数和移动赋值运算符转移所有权：

std::unique_ptr<int> p1(new int(42));
std::unique_ptr<int> p2 = std::move(p1); // p1 变为 nullptr

weak_ptr 的作用是什么，它与 shared_ptr 之间是如何配合工作来解决循环引用问题的？

观测 shared_ptr 管理的资源，不增加引用计数。
通过 lock() 安全访问资源：

std::weak_ptr<int> wp = sp; // sp 是 shared_ptr
if (auto spt = wp.lock()) { // 转换为 shared_ptr
    // 使用 spt
}

解决循环引用：
示例：

class B;
class A {
    std::shared_ptr<B> b_ptr;
};
class B {
    std::shared_ptr<A> a_ptr; // 循环引用，引用计数无法归零
};

改进：

class B {
    std::weak_ptr<A> a_ptr; // 使用 weak_ptr 打破循环
};

智能指针在实际项目中有哪些应用场景，举例说明。

智能指针和原始指针相比，有哪些优势和劣势？

优点：

能够自动管理内存，避免内存泄漏、悬空指针、野指针等问题，提高代码的安全性。
能够提升代码的整洁性，不用编写繁琐的内存分配和释放代码，使代码逻辑更加清晰，可读性更好，可维护性更强。

缺点：
性能开销和灵活性降低。

在使用智能指针时，需要注意哪些问题，如何避免常见的错误？

(1) 避免混合使用 new 和智能指针构造函数：
(2) 慎用 get()：

避免通过 get() 获取的原始指针手动释放资源。

(3) 优先使用 make_shared/make_unique：

提升性能并减少内存碎片：

auto p = std::make_shared<int>(42); // 优于 shared_ptr<int>(new int(42))

(4) 尽量不要使用裸指针初始化智能指针？
因为可能存在同一个裸指针初始了多个智能指针，在智能指针析构时会造成资源的多次释放。

为什么优先使用 make_shared/make_unique

(1) make_shared和make_unique是C++11和C++14引入的工厂函数。它们的优势在于，当创建对象时，能够将对象和控制块的内存分配合并为一次。而直接使用new的话，需要先分配对象内存，再分配控制块，这样会有两次内存分配，增加开销和碎片。

std::shared_ptr<Widget> sp(new Widget);  // 两次内存分配：对象 + 控制块

auto sp = std::make_shared<Widget>();    // 一次内存分配：对象和控制块连续存储

合并对象和控制块的内存分配，减少内存碎片和开销。

make_shared 将对象和控制块存储在连续内存中，提高 CPU 缓存命中率，减少访问延迟。

(2) 能保证异常安全。如果在构造智能指针时，参数表达式抛出异常，使用new可能会导致内存泄漏，而make_shared/make_unique因为直接在参数中构造，不会有这个问题。例如，如果有一个函数调用作为参数，可能在new之后，构造shared_ptr之前抛出异常，导致内存泄漏。而make函数会避免这种情况。

示例：潜在的内存泄漏

void process(std::shared_ptr<Widget> sp, int priority);

// 危险！若 getPriority() 抛出异常，new Widget 的内存会泄漏！
process(std::shared_ptr<Widget>(new Widget), getPriority());

使用 make_shared 解决

process(std::make_shared<Widget>(), getPriority()); // 无泄漏风险

原因：make_shared 直接在函数参数中构造智能指针，若后续操作抛出异常，已构造的智能指针会自动释放资源。

(3) 代码简洁性
避免重复类型书写：
make_shared/make_unique 利用 auto 关键字，简化代码：

auto sp = std::make_shared<std::vector<std::string>>(); // 清晰简洁
// vs
std::shared_ptr<std::vector<std::string>> sp(new std::vector<std::string>);

适用场景
默认选择：优先使用 make_shared 和 make_unique，除非有特殊需求。

不适用场景：

需要自定义删除器（如 delete[] 或文件句柄释放）。

需要分离对象和控制块的生命周期（如大量 weak_ptr 长期存在时，make_shared 可能延迟内存释放）。