shared_ptr 链表释放

当使用 shared_ptr 管理链表时，可以避免手动释放内存，因为 shared_ptr 会自动在不再需要时释放所管理的对象。

下面是一个示例代码，展示了如何使用 shared_ptr 管理链表的释放：

#include <memory>

struct Node {
    int data;
    std::shared_ptr<Node> next;

    Node(int val) : data(val), next(nullptr) {}
};

int main() {
    std::shared_ptr<Node> head = std::make_shared<Node>(1);
    std::shared_ptr<Node> node1 = std::make_shared<Node>(2);
    std::shared_ptr<Node> node2 = std::make_shared<Node>(3);

    head->next = node1;
    node1->next = node2;

    // 所有的 shared_ptr 在 main 函数运行结束后会自动释放内存
}

在上面的示例中，我们创建了一个链表，其中每个节点都由一个 shared_ptr 管理。当 main 函数运行结束时，所有的 shared_ptr 会自动释放它们所管理的节点对象，无需手动释放。

这样，使用 shared_ptr 可以避免内存泄漏和悬挂指针等问题，提高代码的健壮性和可维护性。

相关问题

std::shared_ptr<std::list<std::shared_ptr<Phone>>> phoneList; 如何遍历phoneList ？

要遍历`std::shared_ptr<std::list<std::shared_ptr<Phone>>>`类型的`phoneList`，你可以按照以下步骤操作：

1. 首先，确保`phoneList`不是空的（即它至少有一个元素）[^1]，因为`shared_ptr`会自动管理内存生命周期，如果它指向的对象为空，那么它的`expired()`方法会返回`true`。

if (!phoneList.empty()) {
    // continue with the loop
}

2. 使用迭代器遍历`list`。由于`phoneList`实际上是一个共享所有权的链表，你可以通过`begin()`和`end()`方法获取迭代器范围：

for (auto it = phoneList.begin(); it != phoneList.end(); ++it) {
    // 处理每个 Phone 对象
    auto phoneSharedPtr = *it;
    if (!phoneSharedPtr.expired()) {
        const Phone& phone = phoneSharedPtr.lock();
        // 进一步访问 phone 对象的属性或调用其方法
        std::cout << "Phone object: " << phone.getPhoneNumber() << std::endl;
    }
}

这里的`lock()`函数用于获取`shared_ptr`所持有的实际对象，只有当`shared_ptr`非空且有效时才会成功。

c++如何用智能指针实现链表的几种方式，包括用unique_ptr实现、shared_ptr实现

链表是一种常见的数据结构，智能指针可以帮助我们管理链表节点的内存，避免内存泄漏和野指针的问题。下面介绍几种用智能指针实现链表的方式。

1. 用unique_ptr实现

unique_ptr是C++11标准引入的智能指针，每个unique_ptr对象都“独占”所指向的内存资源，即同一时间只能有一个unique_ptr对象拥有该内存资源，其他unique_ptr对象无法访问该内存资源。因此，我们可以用unique_ptr实现链表节点，每个节点拥有唯一的unique_ptr对象。

#include <memory>

template<typename T>
struct Node {
    T data;
    std::unique_ptr<Node<T>> next;

    Node(T data) : data(std::move(data)), next(nullptr) {}
};

template<typename T>
class LinkedList {
public:
    LinkedList() : head(nullptr) {}

    void insert(T data) {
        std::unique_ptr<Node<T>> newNode = std::make_unique<Node<T>>(std::move(data));
        if (!head) {
            head = std::move(newNode);
        } else {
            Node<T>* current = head.get();
            while (current->next) {
                current = current->next.get();
            }
            current->next = std::move(newNode);
        }
    }

private:
    std::unique_ptr<Node<T>> head;
};

2. 用shared_ptr实现

shared_ptr是C++11标准引入的智能指针，多个shared_ptr对象可以“共享”同一个内存资源，即同一时间可以有多个shared_ptr对象拥有该内存资源。因此，我们可以用shared_ptr实现链表节点，每个节点拥有一个shared_ptr对象，多个节点的shared_ptr对象可以共享同一个内存资源。

#include <memory>

template<typename T>
struct Node {
    T data;
    std::shared_ptr<Node<T>> next;

    Node(T data) : data(std::move(data)), next(nullptr) {}
};

template<typename T>
class LinkedList {
public:
    LinkedList() : head(nullptr) {}

    void insert(T data) {
        std::shared_ptr<Node<T>> newNode = std::make_shared<Node<T>>(std::move(data));
        if (!head) {
            head = std::move(newNode);
        } else {
            std::shared_ptr<Node<T>> current = head;
            while (current->next) {
                current = current->next;
            }
            current->next = std::move(newNode);
        }
    }

private:
    std::shared_ptr<Node<T>> head;
};

以上是用智能指针实现链表的两种方式，其中unique_ptr和shared_ptr都可以有效避免内存泄漏和野指针的问题。选择哪种方式取决于具体需求和场景，需要根据实际情况进行选择。