用c++ 写一个链表 ，但必须用智能指针

没问题，以下是用智能指针实现链表的 C++ 代码：

#include <memory>

using namespace std;

struct ListNode {
    int val;
    shared_ptr<ListNode> next; // 智能指针
    ListNode(int x) : val(x), next(nullptr) {}
};

int main() {
    shared_ptr<ListNode> head = make_shared<ListNode>(0);
    shared_ptr<ListNode> prev = head;
    for (int i = 1; i <= 10; i++) {
        shared_ptr<ListNode> node = make_shared<ListNode>(i);
        prev->next = node;
        prev = node;
    }
    return 0;
}

以上代码定义了一个结构体 `ListNode` 代表链表节点，其中包含一个整数 `val` 和一个智能指针 `next`，指向下一个节点。使用 `std::shared_ptr` 作为智能指针，可自动管理内存，不需要手动释放。

代码创建了一个链表，以头结点为起点，循环添加 10 个节点，最后返回 0 表示成功执行。

希望能满足您的需求。

相关问题

用 c++ 20 写一个链表 ,指针请用 智能指针。

非常感谢您的提问。以下是使用 C++20 编写链表的示例代码，其中使用了智能指针：

#include <iostream>
#include <memory>

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

    Node(const T& data) : data(data), next(nullptr) {}
};

template <typename T>
class LinkedList {
public:
    LinkedList() : head(nullptr), tail(nullptr), size(0) {}

    void push_back(const T& data) {
        auto node = std::make_shared<Node<T>>(data);
        if (!head) {
            head = node;
            tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
        size++;
    }

    void print() const {
        auto node = head;
        while (node) {
            std::cout << node->data << " ";
            node = node->next;
        }
        std::cout << std::endl;
    }

private:
    std::shared_ptr<Node<T>> head;
    std::shared_ptr<Node<T>> tail;
    size_t size;
};

int main() {
    LinkedList<int> list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    list.print();
    return 0;
}

希望这个示例代码能够帮助您。

用c++写一个类的双指针链表

好的，我可以回答这个问题。以下是一个用 C 语言编写的双指针链表类的示例代码：

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
} Node;

typedef struct List {
    Node* head;
    Node* tail;
} List;

List* createList() {
    List* list = (List*) malloc(sizeof(List));
    list->head = NULL;
    list->tail = NULL;
    return list;
}

void addNode(List* list, int data) {
    Node* node = (Node*) malloc(sizeof(Node));
    node->data = data;
    node->prev = list->tail;
    node->next = NULL;
    if (list->tail != NULL) {
        list->tail->next = node;
    }
    list->tail = node;
    if (list->head == NULL) {
        list->head = node;
    }
}

void printList(List* list) {
    Node* node = list->head;
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

int main() {
    List* list = createList();
    addNode(list, 1);
    addNode(list, 2);
    addNode(list, 3);
    printList(list);
    return ;
}

这个类包含两个结构体：`Node` 和 `List`。`Node` 结构体表示链表中的一个节点，包含一个整数数据、一个指向前一个节点的指针和一个指向后一个节点的指针。`List` 结构体表示整个链表，包含一个指向头节点的指针和一个指向尾节点的指针。

这个类提供了三个函数：`createList`、`addNode` 和 `printList`。`createList` 函数用于创建一个新的链表，返回一个指向该链表的指针。`addNode` 函数用于向链表中添加一个新节点，接受一个整数参数作为新节点的数据。`printList` 函数用于打印链表中所有节点的数据。

在 `main` 函数中，我们创建了一个新的链表，向其中添加了三个节点，然后打印了整个链表的数据。

希望这个示例代码能够帮助你理解如何用 C 语言编写一个双指针链表类。