✍个人博客：Pandaconda-CSDN博客
📣专栏地址：http://t.csdnimg.cn/fYaBd
📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~
❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

7. 智能指针是线程安全的吗？如何保证线程安全？

不是。C++ 中的智能指针，例如 std::shared_ptr 和 std::unique_ptr，本质上是一种封装了指针的数据类型，它们管理对象的生命周期，并确保在不再需要时自动释放资源。但是，这些智能指针本身不具有线程安全特性。如果多个线程同时访问同一个智能指针，则需要使用额外的同步机制 (例如锁) 来保证它们的正确性。
为了确保智能指针的线程安全性，可以结合使用互斥锁或原子操作来保护对智能指针的访问。下面是一个具体的示例：

#include <iostream>
#include <mutex>
#include <memory>
#include <thread>
std::mutex mtx;
void modifySharedPointer(std::shared_ptr<int>& sp) {
    std::unique_lock<std::mutex> lock(mtx);
    // 对智能指针进行修改操作
    *sp += 1;
}
void accessSharedPointer(const std::shared_ptr<int>& sp) {
    std::unique_lock<std::mutex> lock(mtx);
    // 对智能指针进行读取操作
    std::cout << "Value: " << *sp << std::endl;
}
int main() {
    std::shared_ptr<int> sp = std::make_shared<int>(0);
    std::thread t1(modifySharedPointer, std::ref(sp));
    std::thread t2(accessSharedPointer, std::ref(sp));
    t1.join();
    t2.join();
    return 0;
}

在以上示例中，我们使用了一个互斥锁 std::mutex 来保护对智能指针的读写操作。通过 std::unique_lock 创建的锁对象，在访问智能指针时会自动加锁，并在适当的时候释放锁。
这样就能确保多个线程在访问智能指针时的互斥性，从而保证线程安全性。

8. 智能指针如何自定义删除器

template<typename T>
class MyDeletor
{
public:
    void operator()(T* ptr)const
    {
        cout<<"call MyDeletor.operator()"<<endl;
        delete[]ptr;
    }
};

template<typename T>
class MyFileDeletor
{
public:
    void operator()(T* ptr)const
    {
        cout<<"call MyFileDeletor.operator()"<<endl;
        fclose(ptr);
    }
};

int main()
{
    unique_ptr<int, MyDeletor<int>> ptr1(new int[100]); // delete []ptr1
    unique_ptr<FILE, MyFILEDeletor<FILE>> ptr2(fopen("data.txt", "w"));
    
    return 0;
}

上面的写法一个不好的地方就是 class 自定义删除类万一只用一次，那就挺占空间的，代码就需要一直放到上面，有多少不同的类型就要写多少自定义删除类。所以我们可以改成用 lambda 表达式的形式：

unique_ptr<int, function<void(int*)>> ptr1(new int[100], [](int* p)->void){
    cout<<"call lambda release new int[100]"<<endl;
    delete[]p;
};

unique_ptr<FILE, function<void(FILE*)>> ptr2(fopen("data.txt", "w"), [](FILE* p)->void){
    cout<<"call lambda release new fopen"<<endl;
    fclose(p);
};

9. make_shared 的实现原理

make_shared 先会调用 std::allocate_shared 来分配内存，然后再调用构造函数。它和直接用 new 赋值给智能指针的区别在于，直接 new 需要创建两次内存，new 的时候分配一次内存，然后构建智能指针时又会分配一次内存，这可能会增加内存碎片。而 make_shared 就将这两次内存分配减少到了一次，提高了效率。
例如：

shared_ptr<int> sp1(new int(10));

按照上面这样初始化可能会存在缺陷，因为底层需要分配两块内存，如果其中一块申请成功而另一块申请失败，那么资源就会泄漏。

shared_ptr<int> sp2 = make_shared<int>(10);

如果用 make_shared 来进行初始化，则它会将两块内存合并在一起生成，即只分配了一次内存。如果不使用make_shared，当 new int 时候成功，但是 new _Ref_count_base 失败时，share_ptr 在构造时失败，无法调用析构函数，导致 new int 的内存无法释放；

缺点：

1. make_shared 不能自定义删除器.
2. 导致托管的资源延迟释放，即使强智能指针引用计数减为 0，但是弱智能指针仍有计数则资源不能释放，因为都在同一块内存，要释放会一起释放。