什么是智能指针C++

• 问题一：一个例子理解什么是智能指针。

假设我们有一个 Person 类，表示人员信息，其中包含姓名和年龄两个成员变量。我们可以使用 shared_ptr 和 make_shared 创建和管理这个类的实例。

#include <iostream>
#include <memory>

class Person {
public:
  std::string name;
  int age;

  Person(const std::string& n, int a) : name(n), age(a) {
    std::cout << "Constructing Person: " << name << std::endl;
  }

  ~Person() {
    std::cout << "Destructing Person: " << name << std::endl;
  }
};

int main() {
  // 使用 shared_ptr 创建对象
  std::shared_ptr<Person> person1(new Person("Alice", 25));
  std::cout << "Name: " << person1->name << ", Age: " << person1->age << std::endl;

  // 使用 make_shared 创建对象
  std::shared_ptr<Person> person2 = std::make_shared<Person>("Bob", 30);
  std::cout << "Name: " << person2->name << ", Age: " << person2->age << std::endl;

  return 0;
}

在上面的例子中，我们首先使用 shared_ptr 的构造函数创建了一个 Person 对象 person1，通过 new 运算符手动分配内存，并将其封装在 shared_ptr 中。然后，我们使用 make_shared 创建了另一个 Person 对象 person2，该函数会在单次内存分配中同时分配对象和引用计数。两种方式都可以正常使用智能指针来管理对象的生命周期。

当程序运行结束时，会自动调用 shared_ptr 的析构函数，自动释放内存。输出结果如下：

Constructing Person: Alice
Name: Alice, Age: 25
Constructing Person: Bob
Name: Bob, Age: 30
Destructing Person: Bob
Destructing Person: Alice

可以看出，创建对象的时候，构造和析构都是由智能指针来管理的。需要注意使用make_shared创建对象的时候，构造与析构都是连续的，这是因为对象和引用计数都是共享一块内存。

总的来说，shared_ptr 的构造函数和 make_shared 都可以用于创建对象并管理其生命周期，但是 make_shared 提供了更好的性能和异常安全性，并且可以减少内存分配和引用计数的额外开销。因此，在实际开发中，推荐使用 make_shared 来创建和管理对象的智能指针。

• 问题二：通过智能指针来创建对象与直接创建类对象有什么不同？

通过智能指针来创建类对象和直接创建类对象有以下区别：

1. 所有权管理：智能指针（如shared_ptr）可以管理对象的所有权。它们使用引用计数来跟踪对象的引用数，并在没有引用时自动释放对象。这可以避免手动跟踪和释放对象的内存，减少了内存泄漏和悬挂指针的风险。
2. 生命周期管理：通过智能指针创建的对象在没有引用时会自动销毁，因为智能指针负责在适当的时候调用析构函数释放内存。而直接创建的对象需要手动调用析构函数来释放内存，容易忘记或出错。
3. 异常安全性：使用智能指针可以提供异常安全性，即在发生异常时，智能指针会自动处理资源的释放，避免资源泄漏。而直接创建的对象需要手动编写异常处理代码来确保资源的正确释放。
4. 共享和复制：某些智能指针（如shared_ptr）可以实现共享和复制语义。多个智能指针可以指向同一个对象，共享对象的所有权和状态。而直接创建的对象通常需要手动实现共享和复制的逻辑。

• 问题三: unique_ptr和shared_ptr有什么区别呢？

unique_ptr 和 shared_ptr 都是智能指针，用于管理动态分配的对象的内存。它们的主要区别在于所有权管理和内存释放的方式：

1. 所有权管理：unique_ptr 独占所指向的对象的所有权，即同一时间只能有一个 unique_ptr 指向该对象，而 shared_ptr 可以有多个共享指针同时指向同一个对象。
2. 内存释放：当 unique_ptr 超出作用域或被显式地重置时，它拥有的对象会被自动销毁并释放内存；而 shared_ptr 只有当所有指向该对象的 shared_ptr 都被销毁时，才会销毁对象并释放内存。

下面是一个比较示例，展示了 unique_ptr 和 shared_ptr 的不同行为：

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass constructor." << std::endl;
    }

    ~MyClass() {
        std::cout << "MyClass destructor." << std::endl;
    }
};

void UniquePtrExample() {
    std::unique_ptr<MyClass> uniquePtr(new MyClass());
    std::cout << "Inside UniquePtrExample()" << std::endl;
}  // uniquePtr 超出作用域，MyClass 对象被销毁并释放内存

void SharedPtrExample() {
    std::shared_ptr<MyClass> sharedPtr1(new MyClass());
    std::shared_ptr<MyClass> sharedPtr2 = sharedPtr1;
    std::cout << "Inside SharedPtrExample()" << std::endl;
}  // sharedPtr1 和 sharedPtr2 超出作用域，MyClass 对象被销毁并释放内存

int main() {
    UniquePtrExample();
    std::cout << "After UniquePtrExample()" << std::endl;

    SharedPtrExample();
    std::cout << "After SharedPtrExample()" << std::endl;

    return 0;
}

输出结果：

MyClass constructor.
Inside UniquePtrExample()
MyClass destructor.
After UniquePtrExample()
MyClass constructor.
Inside SharedPtrExample()
After SharedPtrExample()
MyClass destructor.

从输出结果可以看出：

• 在 UniquePtrExample() 函数中，unique_ptr 超出作用域时，MyClass 对象被销毁并释放内存。
• 在 SharedPtrExample() 函数中，即使 sharedPtr1 和 sharedPtr2 超出作用域，MyClass 对象直到最后一个 shared_ptr 被销毁时才被销毁并释放内存。

因此，unique_ptr 适用于需要独占所有权的情况，而 shared_ptr 适用于多个指针共享对象所有权的情况。根据具体的使用场景和需求，选择合适的智能指针类型可以更好地管理对象的生命周期和内存释放。