C++中创建通用类型链表的实践

已于 2023-12-01 17:22:36 修改
阅读量64 收藏
点赞数 1
文章标签： c++ c语言 数据结构 链表
于 2023-12-01 17:18:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alvin_NY/article/details/134738230
版权

在C++中创建通用类型链表

在本文中，我们将探讨如何在C++中创建一个自定义链表结构，用于储存任意类型的数据文章中包含了两个完整的用例，自定义一个包含当前坐标和前一个坐标的点的结构体，并用我们的通用链表储存起来。

在C++中，一个通用的链表结构体通常涉及到模板的使用，这样可以允许链表存储任何类型的数据。以下是使用C++模板实现的一个通用链表类的示例，包括了链表节点结构体和链表类本身。链表节点使用指针来存储数据，而链表类提供了在链表前后插入和删除节点的方法，以及其他有用的功能。

#include <iostream>
#include <memory>

// 链表节点的定义
template <typename T>
struct ListNode {
    std::unique_ptr<T> data; // 使用unique_ptr来自动管理内存
    ListNode<T>* next;

    // 构造函数，用于初始化节点
    ListNode(T* data) : data(data), next(nullptr) {}

    // 禁止拷贝构造和赋值
    ListNode(const ListNode&) = delete;
    ListNode& operator=(const ListNode&) = delete;

    // 支持移动构造和赋值
    ListNode(ListNode&&) = default;
    ListNode& operator=(ListNode&&) = default;
};

// 链表类的定义
template <typename T>
class LinkedList {
private:
    ListNode<T>* head;
    ListNode<T>* tail;

public:
    // 构造函数
    LinkedList() : head(nullptr), tail(nullptr) {}

    // 禁止拷贝构造和赋值
    LinkedList(const LinkedList&) = delete;
    LinkedList& operator=(const LinkedList&) = delete;

    // 支持移动构造和赋值
    LinkedList(LinkedList&&) = default;
    LinkedList& operator=(LinkedList&&) = default;

    // 析构函数
    ~LinkedList() {
        clear();
    }

    // 在链表前端插入节点
    void push_front(T* data) {
        ListNode<T>* node = new ListNode<T>(data);
        if (!head) {
            head = tail = node;
        } else {
            node->next = head;
            head = node;
        }
    }

    // 在链表末端插入节点
    void push_back(T* data) {
        ListNode<T>* node = new ListNode<T>(data);
        if (!head) {
            head = tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }

    // 从链表前端删除节点
    std::unique_ptr<T> pop_front() {
        if (!head) {
            return nullptr;
        }
        ListNode<T>* old_head = head;
        head = head->next;
        if (head == nullptr) {
            tail = nullptr;
        }
        return std::move(old_head->data);
    }

    // 从链表末端删除节点
    std::unique_ptr<T> pop_back() {
        if (!head) {
            return nullptr;
        }
        if (head == tail) {
            return pop_front();
        }
        ListNode<T>* current = head;
        while (current->next != tail) {
            current = current->next;
        }
        std::unique_ptr<T> data = std::move(tail->data);
        delete tail;
        tail = current;
        tail->next = nullptr;
        return data;
    }

    // 检查链表是否为空
    bool empty() const {
        return head == nullptr;
    }

    // 清除链表中的所有节点
    void clear() {
        while (head != nullptr) {
            pop_front();
        }
    }

    // 打印链表中的元素（需要T类型支持输出操作）
    void print() const {
        ListNode<T>* current = head;
        while (current != nullptr) {
            std::cout << *(current->data) << " -> ";
            current = current->next;
        }
        std::cout << "null" << std::endl;
    }
};

// 示例使用
int main() {
    LinkedList<int> list;

    // 在链表末端添加元素
    list.push_back(new int(1));
    list.push_back(new int(2));
    list.push_back(new int(3));

    // 打印链表
    list.print();

    // 从链表前端删除元素
    auto data = list.pop_front();
    if (data) {
        std::cout << "Popped from front: " << *data << std::endl;
    }

    // 再次打印链表
    list.print();

    // 清除链表
    list.clear();

    return 0;
}

这个链表类使用了unique_ptr来自动管理内存，确保不会发生内存泄漏。请注意，这个实现假设存储在链表中的类型T支持输出操作（即重载了operator<<），这样才能在print方法中打印每个元素。如果类型T不支持输出操作，你需要移除或者修改print方法。

在实际使用中，你可能需要根据实际情况调整或者扩展这个链表类的功能，以满足特定的需求。例如，你可能会添加遍历、查找或排序等方法。

自定义数据结构

在任何数据结构的设计中，首先要确定的是它将如何存储和处理数据。在我们的例子中，我们需要存储一系列的点。为了创建一个包含当前坐标 (x, y) 和前一个坐标 (prev_x, prev_y) 的自定义结构体，并将这些结构体组织成链表。

在这个示例中，Point结构体包含了两个整数对，分别表示当前点的x和y坐标，以及先前点的prev_x和prev_y坐标。此外，Point结构体还重载了输出操作符<<，以便于在LinkedList的print方法中直接打印点的信息。

当你在链表中添加Point实例时，你需要手动管理这些实例的内存，因为我们使用了裸指针。在本例中，我们通过new操作符创建了Point的实例，并通过push_back方法添加到链表中。当我们通过pop_front方法从链表中移除一个Point实例时，unique_ptr会自动释放这个实例占用的内存。在实际应用中，你可能需要考虑使用智能指针来进一步简化内存管理。

#include <iostream>
#include <memory>
// ... (包含先前提供的ListNode和LinkedList的定义)

// 定义一个表示点的结构体
struct Point {
    int x, y; // 当前点的坐标
    int prev_x, prev_y; // 先前点的坐标

    Point(int x, int y, int prev_x, int prev_y)
        : x(x), y(y), prev_x(prev_x), prev_y(prev_y) {}

    // 输出操作符重载，用于打印点的信息
    friend std::ostream& operator<<(std::ostream& os, const Point& point) {
        os << "Current: (" << point.x << ", " << point.y << "), "
           << "Previous: (" << point.prev_x << ", " << point.prev_y << ")";
        return os;
    }
};

// 示例使用
int main() {
    // 创建一个链表，存储Point结构体
    LinkedList<Point> pointList;

    // 添加点到链表
    pointList.push_back(new Point(1, 2, 0, 0));
    pointList.push_back(new Point(3, 4, 1, 2));
    pointList.push_back(new Point(5, 6, 3, 4));

    // 打印链表中的点
    pointList.print();

    // 从链表前端删除点
    auto data = pointList.pop_front();
    if (data) {
        std::cout << "Popped from front: " << *data << std::endl;
    }

    // 再次打印链表
    pointList.print();

    // 清除链表
    pointList.clear();

    return 0;
}

完整代码

#include <iostream>
#include <memory>

// 链表节点的定义
template <typename T>
struct ListNode {
    std::unique_ptr<T> data; // 使用unique_ptr来自动管理内存
    ListNode<T>* next;

    // 构造函数，用于初始化节点
    ListNode(T* data) : data(data), next(nullptr) {}

    // 禁止拷贝构造和赋值
    ListNode(const ListNode&) = delete;
    ListNode& operator=(const ListNode&) = delete;

    // 支持移动构造和赋值
    ListNode(ListNode&&) = default;
    ListNode& operator=(ListNode&&) = default;
};

// 链表类的定义
template <typename T>
class LinkedList {
private:
    ListNode<T>* head;
    ListNode<T>* tail;

public:
    // 构造函数
    LinkedList() : head(nullptr), tail(nullptr) {}

    // 禁止拷贝构造和赋值
    LinkedList(const LinkedList&) = delete;
    LinkedList& operator=(const LinkedList&) = delete;

    // 支持移动构造和赋值
    LinkedList(LinkedList&&) = default;
    LinkedList& operator=(LinkedList&&) = default;

    // 析构函数
    ~LinkedList() {
        clear();
    }

    // 在链表前端插入节点
    void push_front(T* data) {
        ListNode<T>* node = new ListNode<T>(data);
        if (!head) {
            head = tail = node;
        } else {
            node->next = head;
            head = node;
        }
    }

    // 在链表末端插入节点
    void push_back(T* data) {
        ListNode<T>* node = new ListNode<T>(data);
        if (!head) {
            head = tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }

    // 从链表前端删除节点
    std::unique_ptr<T> pop_front() {
        if (!head) {
            return nullptr;
        }
        ListNode<T>* old_head = head;
        head = head->next;
        if (head == nullptr) {
            tail = nullptr;
        }
        return std::move(old_head->data);
    }

    // 从链表末端删除节点
    std::unique_ptr<T> pop_back() {
        if (!head) {
            return nullptr;
        }
        if (head == tail) {
            return pop_front();
        }
        ListNode<T>* current = head;
        while (current->next != tail) {
            current = current->next;
        }
        std::unique_ptr<T> data = std::move(tail->data);
        delete tail;
        tail = current;
        tail->next = nullptr;
        return data;
    }

    // 检查链表是否为空
    bool empty() const {
        return head == nullptr;
    }

    // 清除链表中的所有节点
    void clear() {
        while (head != nullptr) {
            pop_front();
        }
    }

    // 打印链表中的元素（需要T类型支持输出操作）
    void print() const {
        ListNode<T>* current = head;
        while (current != nullptr) {
            std::cout << *(current->data) << " -> ";
            current = current->next;
        }
        std::cout << "null" << std::endl;
    }
};

// 定义一个表示点的结构体
struct Point {
    int x, y; // 当前点的坐标
    int prev_x, prev_y; // 先前点的坐标

    Point(int x, int y, int prev_x, int prev_y)
        : x(x), y(y), prev_x(prev_x), prev_y(prev_y) {}

    // 输出操作符重载，用于打印点的信息
    friend std::ostream& operator<<(std::ostream& os, const Point& point) {
        os << "Current: (" << point.x << ", " << point.y << "), "
           << "Previous: (" << point.prev_x << ", " << point.prev_y << ")";
        return os;
    }
};


// 示例使用
int main() {
    LinkedList<int> list;

    // 在链表末端添加元素
    list.push_back(new int(1));
    list.push_back(new int(2));
    list.push_back(new int(3));

    // 打印链表
    list.print();

    // 从链表前端删除元素
    auto data = list.pop_front();
    if (data) {
        std::cout << "Popped from front: " << *data << std::endl;
    }

    // 再次打印链表
    list.print();

    // 清除链表
    list.clear();


    // 创建一个链表，存储Point结构体
    LinkedList<Point> pointList1;

    // 添加点到链表
    pointList1.push_back(new Point(1, 2, 0, 0));
    pointList1.push_back(new Point(3, 4, 1, 2));
    pointList1.push_back(new Point(5, 6, 3, 4));

    // 打印链表中的点
    pointList1.print();

    // 从链表前端删除点
    auto data1 = pointList1.pop_front();
    if (data1) {
        std::cout << "Popped from front: " << *data1 << std::endl;
    }

    // 再次打印链表
    pointList1.print();

    // 清除链表
    pointList1.clear();
    return 0;
}

总结

通过本文的指导，你现在可以在C++中创建一个功能齐全的通用链表。这种数据结构不仅增加了代码的灵活性和可重用性，而且通过智能指针的使用，还提高了程序的安全性和内存管理效率。记住，无论是创建链表还是其他复杂数据结构，核心在于理解和应用面向对象的原则，以及熟悉C++的模板和内存管理机制。随着实践的增加，你将能更加熟练地运用这些技术来解决各种编程挑战。

Alvin_NY
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 8万+
C/C++学习路线总结与分享
用类的方式实现C++链表功能
05-29
在C++编程中，链表是一种非常基础且重要的数据结构，它通过节点之间的指针连接形成线性序列。本教程将介绍如何使用类的方式来实现一个简单的C++链表，包括链表的创建、插入、删除、修改和查找操作。下面我们将详细...
c++学习：类模板+万能版链表实战
weixin_59669309的博客
01-04 591
实战 设计一个单向链表类模板 --万能版链表。如果还要比较其他不同数据的类，那需要很多个类。思考类模板能不能作为基类被继承。设计一个任意数据类型的数组模板。解决方法 创建类模板。
C++实现自定义数据类型的单链表
qq_43438974的博客
03-06 294
C++实现自定义数据类型的单链表
C++实现链表
cnds123的专栏
02-21 5462
C++实现链表。本文介绍两种实现方法：一、使用指针自定义实现；二、使用C++ STL（标准模板库）中的list容器实现。
最详细的C++单向链表实现
热门推荐
qq_41696018的博客
08-15 1万+
链表是数据结构中常见的一种数据存储形式，其在物理存储单元上是非连续的存储结构，即其数据存储的空间并非连续的内存空间。这种存储方式的优点是可以动态分配内存空间，不会造成内存的浪费和溢出，同时链表对于执行插入、删除等操作十分简便，不需要移动大量元素，但是其相对于连续空间存储的数据相比，遍历速度较慢。 1、那么链表到底长啥样呢？ 链表由多个node(节点)组成，每个节点中由两部分结构组成，data中存储需要存储的数据，next为一个指针，其指向下一个node的地址。 当...
反转链表详解
Weirdo的博客
06-14 1568
这些数据项通常以链表的形式组织起来，其中最近使用的数据项位于链表的头部，最久未使用的数据项位于链表的尾部。反转链表指的是将链表的头尾节点对调，使得原本链表的第一个节点变为最后一个节点，原本链表的最后一个节点变为第一个节点，其他节点的相对位置也进行相应调整。通过对反转链表算法的深入理解和实践应用，我们可以更好地掌握链表的基本操作和指针的使用，并提高编程能力和解决问题的能力。然而，锁的使用会降低程序的性能。在实际应用中，我们可能需要在反转链表的同时进行其他操作，例如计算链表长度、检查链表中的重复元素等。
【算法】合并两个有序链表：C++
master_chenchen的博客
06-29 640
合并两个有序链表是一个链表操作的典型场景，它涉及到链表节点的遍历与比较，最终构造出一个有序序列。C++的指针操作能力在此类问题中显得尤为重要。本文通过合并两个有序链表这一经典案例，展现了C++在链表操作及算法实现上的独特魅力。掌握链表合并不仅是算法学习的基础，更是深入理解数据结构与算法设计原则的关键步骤。展望未来，随着算法研究的不断深入和技术的迭代，链表操作及其衍生问题将在更多领域展现其价值，而C++作为强大的工具，将继续为高效算法实现提供坚实支撑。
深入理解 C++ 自定义链表中实现迭代器
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
09-30 409
链表和迭代器在C++中的应用广泛，是数据管理和操作的基础。掌握它们，就像掌握了解决复杂问题的钥匙。正如《Effective C++》中所说：“掌握C++的核心，不仅在于理解其语法，更在于懂得如何有效地利用它。”（"Mastering the core of C++ is not just about understanding its syntax but also knowing how to use it effectively."）
c++(更新中~)
qq_35621280的博客
08-29 1078
/ 定义命名空间// 在命名空间中定义变量、函数、类等int x;// 变量声明// 函数声明// 类声明// 在命名空间外定义函数的实现// 函数实现。
C++指针和链表在项目开发中的实战应用
08-16
模板类允许开发者创建通用的链表类，该类能够存储任何类型的数据。在实现模板链表类时，需要特别注意泛型编程的细节，确保代码的正确性和效率。 构建集成测试框架时，应包括以下步骤： 1. **单元测试**：针对链表...
cpp代码-C/C++ 通用链表代码测试
07-14
- **模板类**：如果要实现通用链表，可以使用C++的模板机制，使得链表可以存储任何类型的数据。 - **RAII（Resource Acquisition Is Initialization）**：遵循此原则，可以在对象生命周期内自动管理资源。 4. **...
C++基础应用———通讯录(链表）.rar
07-17
在本项目中，"C++基础应用———通讯录(链表）.rar"是一个包含C++编程实现的通讯录系统。这个系统基于结构体和链表数据结构，旨在教授初学者如何运用C++的基本概念来创建一个实用的程序。下面我们将详细探讨通讯录...
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 685
C语言 | Leetcode C语言题解之第389题找不同
C语言作用域
天道酬勤
09-07 987
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 316
QWidget(c++)嵌入window环境的exe
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 968
💫往期文章👇：
C和指针：标准函数库
最新发布
暮色年华的博客
09-11 547
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值