【c++智能指针】

原理：

智能指针是 C++ 中的一种特殊指针，它能够自动管理所指对象的内存，避免了手动管理内存的麻烦和错误。

智能指针的实现原理主要是通过 RAII 技术来实现的。RAII（Resource Acquisition Is Initialization）是一种 C++ 中的编程技术，它通过在对象构造时获取资源，在对象析构时释放资源，来保证资源的正确获取和释放。智能指针利用了 RAII 技术来自动管理所指对象的内存。智能指针通常是一个类模板，它封装了一个指针，并提供了自动管理内存的功能。

智能指针的实现通常包括以下几个步骤：

在智能指针的构造函数中，分配所指对象的内存，并将其地址存储在智能指针中。
在智能指针的析构函数中，释放所指对象的内存。
在智能指针的拷贝构造函数和赋值操作中，更新引用计数并共享所指对象的内存。
引用计数是智能指针实现共享式引用的关键。在共享式智能指针中，每个智能指针都有一个引用计数，记录有多少个智能指针指向同一个对象。当一个新的智能指针指向同一个对象时，引用计数加 1；当一个智能指针被销毁时，引用计数减 1。当引用计数为 0 时，表示没有智能指针指向该对象，此时释放该对象的内存。

智能指针自动释放内存的原理是在智能指针的析构函数中，调用 delete 运算符来释放指针所指对象的内存。由于智能指针是一个对象，它遵循 RAII 原则，在构造函数中获取资源，在析构函数中释放资源。因此，当智能指针对象被销毁时，其析构函数会被自动调用，从而自动释放指针所指对象的内存。

在 C++ 中，智能指针通常是一个类模板，它封装了一个指针，并提供了自动管理内存的功能。

以下是一个简单的智能指针的实现，用于展示智能指针是如何实现的：

template<typename T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr) : m_ptr(ptr) {}
    ~SmartPtr() {
        delete m_ptr;
    }
    T* operator->() {
        return m_ptr;
    }
    T& operator*() {
        return *m_ptr;
    }
private:
    T* m_ptr;
};

在上面的代码中，我们定义了一个名为 SmartPtr 的类模板，它有一个模板参数 T，表示指针所指对象的类型。

在类的私有成员中，我们定义了一个指向 T 类型对象的指针 m_ptr。

在类的公有成员中，我们定义了一个构造函数，可以使用一个裸指针初始化智能指针；

一个析构函数，用于释放指针所指对象的内存；

一个 -> 运算符重载函数，用于返回指针所指对象的指针；

一个 * 运算符重载函数，用于返回指针所指对象的引用。

可以看到，智能指针的实现主要是通过类和模板技术来实现的，它封装了一个指针，并提供了自动管理内存的功能。

在智能指针的析构函数中，我们调用了 delete 运算符来释放指针所指对象的内存。由于智能指针是一个对象，它遵循 RAII 原则，在构造函数中获取资源，在析构函数中释放资源。因此，当智能指针对象被销毁时，其析构函数会被自动调用，从而自动释放指针所指对象的内存。

在实际使用中，智能指针的实现可能更加复杂，例如引用计数、线程安全等问题需要进行处理。

1.std::unique_ptr

std::unique_ptr 是 C++11 中引入的一种智能指针，它是一种独占式智能指针，即同一时间只能有一个指针指向该对象。

它的特点是能够自动释放所指对象的内存，并且不允许进行拷贝或者赋值操作，因此可以避免资源的重复释放和悬挂指针的问题。

以下是 std::unique_ptr 的一些常用方法：

std::unique_ptr：定义一个指向类型为 T 的对象的智能指针。
std::unique_ptr p(new T(args…))：使用 new 运算符创建一个类型为 T 的对象，并将其地址赋值给智能指针 p。
p.get()：获取智能指针 p 所指对象的指针，返回一个裸指针。
p.release()：释放智能指针 p 对所指对象的所有权，并返回一个裸指针。
p.reset()：释放智能指针 p 对所指对象的所有权，并将智能指针 p 重置为空指针。
p.reset(new T(args…))：释放智能指针 p 对所指对象的所有权，并使用 new 运算符创建一个类型为 T 的对象，并将其地址赋值给智能指针 p。
p.reset(nullptr)：释放智能指针 p 对所指对象的所有权，并将智能指针 p 重置为空指针。
p.operator bool()：判断智能指针 p 是否为空指针，如果不为空指针，则返回 true，否则返回 false。
以下是一个使用 std::unique_ptr 的例子：

#include <iostream>
#include <memory>
 
int main() {
    std::unique_ptr<int> p(new int(123));
    std::cout << "*p = " << *p << std::endl;
    p.reset(new int(456));
    std::cout << "*p = " << *p << std::endl;
    return 0;
}
//输出结果：
//*p = 123
//*p = 456

在上面的例子中，我们使用 std::unique_ptr 定义了一个指向整数类型的智能指针 p，并通过 new 运算符分配了一个整数类型的对象，并将其地址赋值给 p。

由于 std::unique_ptr 是独占式智能指针，因此同一时间只有一个指针可以指向该对象。在程序执行过程中，我们使用 reset 方法释放了 p 对所指对象的所有权，

并使用 new 运算符创建了一个新的整数类型的对象，并将其地址赋值给 p。需要注意的是，由于 reset 方法释放了旧对象的内存，因此无需手动释放内存。

2.std::shared_ptr

std::shared_ptr 是 C++11 中引入的一种智能指针，它是一种共享式智能指针，即可以有多个指针指向同一个对象。它的特点是能够自动释放所指对象的内存，并且可以进行拷贝或者赋值操作，因此可以方便地进行资源的共享和传递。

以下是 std::shared_ptr 的一些常用方法：

std::shared_ptr：定义一个指向类型为 T 的对象的智能指针。
std::shared_ptr p(new T(args…))：使用 new 运算符创建一个类型为 T 的对象，并将其地址赋值给智能指针 p。
p.get()：获取智能指针 p 所指对象的指针，返回一个裸指针。
p.use_count()：获取智能指针 p 所指对象的引用计数，即指向该对象的智能指针的数量。
p.unique()：判断智能指针 p 是否是唯一的，即指向该对象的智能指针是否只有一个。
p.reset()：释放智能指针 p 对所指对象的所有权，并将智能指针 p 重置为空指针。
p.reset(new T(args…))：释放智能指针 p 对所指对象的所有权，并使用 new 运算符创建一个类型为 T 的对象，并将其地址赋值给智能指针 p。
p.reset(nullptr)：释放智能指针 p 对所指对象的所有权，并将智能指针 p 重置为空指针。
std::shared_ptr q = p：使用 = 运算符进行拷贝构造，将智能指针 q 指向智能指针 p 所指对象，并将引用计数加 1。
p = q：使用 = 运算符进行赋值操作，将智能指针 p 指向智能指针 q 所指对象，并将引用计数加 1，同时将原来所指对象的引用计数减 1。
以下是一个使用 std::shared_ptr 的例子：

#include <iostream>
#include <memory>
 
int main() {
    std::shared_ptr<int> p1(new int(123));
    std::shared_ptr<int> p2 = p1;
    std::cout << "*p1 = " << *p1 << ", *p2 = " << *p2 << std::endl;
    std::cout << "p1.use_count() = " << p1.use_count() << std::endl;
    return 0;
}
//输出结果应该为：
//*p1 = 123, *p2 = 123
//p1.use_count() = 2

在上面的例子中，我们使用 std::shared_ptr 定义了两个指向整数类型的智能指针 p1 和 p2，并通过 new 运算符分配了一个整数类型的对象，

并将其地址赋值给 p1。由于 std::shared_ptr 是共享式智能指针，因此可以有多个指针指向同一个对象。在程序执行过程中，我们使用 = 运算符进行拷贝构造，

将智能指针 p2 指向智能指针 p1 所指对象，并将引用计数加 1。然后，我们输出智能指针 p1 和 p2 所指对象的值，并使用 use_count 方法获取智能指针 p1 所指

对象的引用计数，即指向该对象的智能指针的数量。

2.1为什么要存在引用计数？作用是什么？

智能指针之所以要用引用计数，是为了实现共享式智能指针，其作用是实现多个智能指针指向同一个对象，从而实现资源的共享和传递。

在智能指针中，引用计数是记录有多少个智能指针指向同一个对象的计数器。当一个新的智能指针指向同一个对象时，引用计数加 1；当一个智能指针被销毁时，引用计数减 1。当引用计数为 0 时，表示没有智能指针指向该对象，此时释放该对象的内存。通过引用计数的机制，可以实现多个智能指针指向同一个对象，从而实现资源的共享和传递。

引用计数的作用主要有以下几点：

实现资源的共享和传递。引用计数可以实现多个智能指针指向同一个对象，从而实现资源的共享和传递，避免了资源的重复创建和销毁，提高了资源的利用率。

避免资源的重复释放。由于智能指针只有在最后一个指针被销毁时才会释放所指对象的内存，因此可以避免资源的重复释放和悬挂指针的问题，提高了程序的稳定性和安全性。

提高程序的效率。由于智能指针自动管理内存，避免了手动管理内存的麻烦和错误，提高了程序的效率和可维护性。

需要注意的是，引用计数机制也存在一些问题，例如引用计数的更新需要保证线程安全，避免引用计数的竞争和冲突；引用计数还存在循环引用的问题，需要进行特殊处理。因此，在使用智能指针时，需要仔细考虑其适用性和限制，并避免出现悬挂指针和循环引用的情况。

3.std::unique_ptr和std::shared_ptr分别适用于什么场景

std::unique_ptr 是一种独占式智能指针，它不能被拷贝，只能通过移动语义来转移所有权，因此适用于以下场景：

管理独占的资源。例如，管理一个动态分配的对象或一个文件句柄等。

避免内存泄漏。由于 std::unique_ptr 在对象析构时自动释放所指对象的内存，因此可以避免内存泄漏的问题。

提高程序的效率。由于 std::unique_ptr 是独占式智能指针，不需要维护引用计数，因此可以提高程序的效率和可维护性。

以下是一个使用 std::unique_ptr 的例子：

#include <iostream>
#include <memory>
 
class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor" << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor" << std::endl;
    }
    void foo() {
        std::cout << "MyClass foo" << std::endl;
    }
};
 
int main() {
    std::unique_ptr<MyClass> p1(new MyClass());
    std::unique_ptr<MyClass> p2 = std::move(p1);
    if (p1 == nullptr) {
        std::cout << "p1 is nullptr" << std::endl;
    }
    p2->foo();
    return 0;
}
 
 
//输出结果应该为：
//MyClass constructor
//p1 is nullptr
//MyClass foo
//MyClass destructor

在上面的例子中，我们使用 std::unique_ptr 定义了两个指向 MyClass 类型对象的智能指针 p1 和 p2，并通过 new 运算符分配了一个 MyClass 类型对象，并将其地址赋值给 p1。由于 std::unique_ptr 是独占式智能指针，不能被拷贝，因此我们使用 std::move 函数将 p1 的所有权转移给 p2。然后，我们判断 p1 是否为空指针，并通过 -> 运算符调用对象的成员函数 foo。

std::shared_ptr 是一种共享式智能指针，它可以有多个指针指向同一个对象，因此适用于以下场景：

管理共享的资源。例如，管理一个动态分配的对象或一个文件句柄等，多个指针可以共享该资源。

避免内存泄漏。由于 std::shared_ptr 在最后一个指针被销毁时自动释放所指对象的内存，因此可以避免内存泄漏的问题。

实现循环引用。由于 std::shared_ptr 支持引用计数，可以实现循环引用的处理，避免了资源无法释放的问题。

以下是一个使用 std::shared_ptr 的例子：

#include <iostream>
#include <memory>
 
class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor" << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructor" << std::endl;
    }
    void foo() {
        std::cout << "MyClass foo" << std::endl;
    }
};
 
int main() {
    std::shared_ptr<MyClass> p1(new MyClass());
    std::shared_ptr<MyClass> p2 = p1;
    std::cout << "p1.use_count() = " << p1.use_count() << std::endl;
    p2->foo();
    return 0;
}
//输出结果应该为：
//MyClass constructor
//p1.use_count() = 2
//MyClass foo
//MyClass destructor

在上面的例子中，我们使用 std::shared_ptr 定义了两个指向 MyClass 类型对象的智能指针 p1 和 p2，并通过 new 运算符分配了一个 MyClass 类型对象，并将其地址赋值给 p1。由于 std::shared_ptr 是共享式智能指针，可以有多个指针指向同一个对象，因此我们使用 = 运算符进行拷贝构造，将智能指针 p2 指向智能指针 p1 所指对象，并将引用计数加 1。然后，我们输出智能指针 p1 的引用计数，并通过 -> 运算符调用对象的成员函数 foo。

可以看到，智能指针 p1 和 p2 共同管理着一个 MyClass 类型对象，引用计数为 2。在程序执行过程中，我们使用 -> 运算符调用对象的成员函数 foo。最后，当智能指针 p1 和 p2 被销毁时，智能指针自动释放所指对象的内存。