基于Qt实现的自定义树结构容器_C/C++

在qt框架中，尽管其提供了许多强大的容器类（如 qlist, qmap, qtreewidget 等），但缺少一个通用的、灵活的树结构容器，直接支持多层级数据管理。为了满足这些需求，本文设计并实现了一个可复用的自定义树结构容器，并讨论其在不同项目中的应用。

1. 背景与动机

树结构在软件开发中是常见的数据组织形式，常用于以下场景：

多层级文件管理器：文件夹与文件的树形展示。
层次化关系管理：如公司组织结构、任务依赖关系。
数据处理与分类：如属性分类、规则树等。

然而，qt 中缺少直接的树结构容器（qtreewidget 是 ui 组件，qabstractitemmodel 偏向于数据视图）。因此，我们实现了一个灵活、可扩展的通用树结构容器，支持：

动态添加和删除节点。
为节点附加数据。
数据筛选与查找。
清晰的树形结构打印与调试。

2. 核心设计与实现

2.1 类设计概览

该树容器包含两个核心类：

treenode：

表示树的单个节点。
包括节点名称、父节点指针、子节点列表、节点数据。
支持节点添加、删除、数据设置与清除等基本操作。

tree：

管理整个树的逻辑。
提供全局的节点操作接口，如添加、删除节点，筛选节点数据，打印树结构等。

2.2 treenode 类实现

treenode 是树结构的核心，负责管理节点的层次关系和数据存储。以下是其关键代码逻辑：

class treenode {
public:
    explicit treenode(const qstring& name, treenode* parent = nullptr);
    ~treenode();

    // 添加子节点
    treenode* addchild(const qstring& name);

    // 移除子节点
    bool removechild(treenode* child);

    // 设置与清除节点数据
    void setdata(const qvariant& data);
    void cleardata();

    // 获取节点信息
    qvariant getdata() const;
    const qlist<treenode*>& getchildren() const;
    qstring getname() const;
    treenode* getparent() const;
};

主要功能：

addchild 和 removechild 实现树的动态结构调整。
setdata 和 cleardata 支持灵活的节点数据管理。
提供对父子关系和数据的访问接口。

2.3 tree 类实现

tree 是一个树容器的管理类。其设计目标是：

提供用户友好的接口，隐藏树节点的内部操作。
支持全局的增删改查功能。

以下是 tree 类的部分接口说明：

class tree {
public:
    tree();
    ~tree();

    // 节点操作
    treenode* addnode(treenode* parent, const qstring& name);
    bool removenode(treenode* node);

    // 数据操作
    void setnodedata(treenode* node, const qvariant& data);
    qvariant getnodedata(treenode* node) const;
    void clearnodedata(treenode* node);

    // 数据筛选与树形打印
    qlist<treenode*> filternodes(const qstring& keyword) const;
    void printtree() const;
};

主要功能：

addnode：动态添加节点，支持将节点默认添加到根节点。
ilternodes：通过关键字查找包含特定数据的节点。
printtree：以层级缩进格式打印树的结构，便于调试。

2.4 调用示例

以下是使用 tree 和 treenode 的示例代码：

int main(int argc, char* argv[]) {
    qcoreapplication a(argc, argv);

    // 创建树容器
    tree tree;

    // 添加节点
    treenode* root = tree.addnode(nullptr, tc("根节点"));
    treenode* nodea = tree.addnode(root, tc("节点a"));
    treenode* nodeb = tree.addnode(root, tc("节点b"));
    treenode* nodec = tree.addnode(nodea, tc("节点c"));

    // 设置节点数据
    tree.setnodedata(nodea, tc("温度过高"));
    tree.setnodedata(nodeb, tc("正常"));
    tree.setnodedata(nodec, tc("压力过低"));

    // 打印树结构
    tree.printtree();

    // 筛选包含 "温度" 的节点
    qlist<treenode*> filterednodes = tree.filternodes(tc("温度"));
    qdebug() << tc("筛选结果:");
    for (treenode* node : filterednodes) {
        qdebug() << node->getname() << ":" << node->getdata().tostring();
    }

    return a.exec();
}

运行结果：

根节点 ()
节点a (温度过高)
节点c (压力过低)
节点b (正常)

筛选结果:
"节点a" : "温度过高"

3. 适用场景分析

该树容器的灵活性使其适用于多种场景，包括但不限于以下项目：

文件管理器：

以层次结构管理文件夹和文件。
节点数据可存储文件的元信息（如路径、大小）。

组织结构管理：

用于显示公司组织架构（如部门、员工）。
节点数据可附加员工信息。

规则引擎或决策树：

用于实现条件匹配规则。
节点存储规则条件与结果。

动态数据分类：

实现类似标签分类的功能。
支持实时增删节点。

调试工具：

用于显示复杂系统中的内部数据关系。

4. 优势与改进方向

4.1 优势

简单易用：

接口友好，隐藏复杂的内部操作。
提供清晰的错误提示和默认行为。

高扩展性：

可以轻松添加新功能，如节点排序、自定义过滤条件等。

灵活性：

节点的数据类型为 qvariant，支持多种数据类型存储。

跨平台支持：

依赖 qt 框架，具备良好的跨平台能力。

4.2 改进方向

线程安全：

增加对并发操作的支持，例如通过 qmutex 实现线程同步。

持久化：

增加树结构的序列化和反序列化功能，用于存储和加载数据。

性能优化：

对大规模树操作（如深度遍历）进行优化。

模型绑定：

将树容器与 qabstractitemmodel 绑定，支持直接用于 qt 的视图类（如 qtreeview）。

5. 结语

本文介绍了一个基于 qt 实现的自定义树结构容器，其功能涵盖了节点管理、数据存储、筛选与打印等操作，适用于多种项目场景。通过该容器，开发者可以更加灵活地管理复杂的层次化数据，同时其清晰的接口设计也便于扩展与维护。

6. 源码

以下是修正后的完整代码实现，包含 treenode.h、treenode.cpp、tree.h、tree.cpp 和 main.cpp 文件。代码修复了根节点初始化问题，并增强了错误处理和默认逻辑。

treenode.h

#ifndef treenode_h
#define treenode_h

#include <qstring>
#include <qlist>
#include <qvariant>

#define tc(a) qstring::fromlocal8bit(a)

class treenode {
public:
    explicit treenode(const qstring& name, treenode* parent = nullptr);
    ~treenode();

    // 添加子节点
    treenode* addchild(const qstring& name);

    // 移除子节点
    bool removechild(treenode* child);

    // 设置节点数据
    void setdata(const qvariant& data);

    // 获取节点数据
    qvariant getdata() const;

    // 移除节点数据
    void cleardata();

    // 获取所有子节点
    const qlist<treenode*>& getchildren() const;

    // 获取节点名称
    qstring getname() const;

    // 获取父节点
    treenode* getparent() const;

    // 检查是否为叶子节点
    bool isleaf() const;

private:
    qstring nodename;             // 节点名称
    qvariant nodedata;            // 节点数据
    treenode* parentnode;         // 父节点
    qlist<treenode*> childnodes;  // 子节点列表
};

#endif // treenode_h

treenode.cpp

#include "treenode.h"
#include <qdebug>

treenode::treenode(const qstring& name, treenode* parent)
    : nodename(name), parentnode(parent) {}

treenode::~treenode() {
    qdeleteall(childnodes); // 删除所有子节点
}

treenode* treenode::addchild(const qstring& name) {
    treenode* child = new treenode(name, this);
    childnodes.append(child);
    return child;
}

bool treenode::removechild(treenode* child) {
    if (!child || !childnodes.contains(child)) {
        qwarning() << tc("移除失败：节点不存在！");
        return false;
    }
    childnodes.removeall(child);
    delete child; // 删除子节点及其数据
    return true;
}

void treenode::setdata(const qvariant& data) {
    nodedata = data;
}

qvariant treenode::getdata() const {
    return nodedata;
}

void treenode::cleardata() {
    nodedata.clear();
}

const qlist<treenode*>& treenode::getchildren() const {
    return childnodes;
}

qstring treenode::getname() const {
    return nodename;
}

treenode* treenode::getparent() const {
    return parentnode;
}

bool treenode::isleaf() const {
    return childnodes.isempty();
}

tree.h

#ifndef tree_h
#define tree_h

#include "treenode.h"

class tree {
public:
    tree();
    ~tree();

    // 添加节点
    treenode* addnode(treenode* parent, const qstring& name);

    // 移除节点
    bool removenode(treenode* node);

    // 设置节点数据
    void setnodedata(treenode* node, const qvariant& data);

    // 获取节点数据
    qvariant getnodedata(treenode* node) const;

    // 移除节点数据
    void clearnodedata(treenode* node);

    // 查找节点（通过名称）
    treenode* findnode(treenode* root, const qstring& name) const;

    // 过滤节点（通过数据关键字）
    qlist<treenode*> filternodes(const qstring& keyword) const;

    // 打印树结构
    void printtree() const;

private:
    treenode* root;

    // 辅助递归方法
    void filterrecursive(treenode* node, const qstring& keyword, qlist<treenode*>& result) const;
    void printrecursive(treenode* node, int depth) const;
};

#endif // tree_h

tree.cpp

#include "tree.h"
#include <qdebug>

tree::tree() {
    root = new treenode(tc("根节点"));
    qdebug() << tc("成功初始化根节点。");
}

tree::~tree() {
    delete root; // 自动删除所有节点
}

treenode* tree::addnode(treenode* parent, const qstring& name) {
    if (!parent) {
        if (!root) {
            qwarning() << tc("添加失败：根节点未创建！");
            return nullptr;
        }
        qdebug() << tc("未指定父节点，默认添加到根节点。");
        parent = root; // 如果父节点为空，默认添加到根节点
    }
    return parent->addchild(name);
}

bool tree::removenode(treenode* node) {
    if (!node || node == root) {
        qwarning() << tc("移除失败：节点为空或为根节点！");
        return false;
    }
    treenode* parent = node->getparent();
    if (!parent) {
        qwarning() << tc("移除失败：父节点为空！");
        return false;
    }
    return parent->removechild(node);
}

void tree::setnodedata(treenode* node, const qvariant& data) {
    if (!node) {
        qwarning() << tc("设置失败：节点为空！");
        return;
    }
    node->setdata(data);
}

qvariant tree::getnodedata(treenode* node) const {
    if (!node) {
        qwarning() << tc("获取失败：节点为空！");
        return qvariant();
    }
    return node->getdata();
}

void tree::clearnodedata(treenode* node) {
    if (!node) {
        qwarning() << tc("清除失败：节点为空！");
        return;
    }
    node->cleardata();
}

treenode* tree::findnode(treenode* root, const qstring& name) const {
    if (!root) return nullptr;
    if (root->getname() == name) return root;

    for (treenode* child : root->getchildren()) {
        treenode* found = findnode(child, name);
        if (found) return found;
    }
    return nullptr;
}

qlist<treenode*> tree::filternodes(const qstring& keyword) const {
    qlist<treenode*> result;
    filterrecursive(root, keyword, result);
    return result;
}

void tree::filterrecursive(treenode* node, const qstring& keyword, qlist<treenode*>& result) const {
    if (node->getdata().tostring().contains(keyword)) {
        result.append(node);
    }
    for (treenode* child : node->getchildren()) {
        filterrecursive(child, keyword, result);
    }
}

void tree::printtree() const {
    printrecursive(root, 0);
}

void tree::printrecursive(treenode* node, int depth) const {
    qdebug().noquote() << qstring(depth * 2, ' ') + node->getname() + " (" + node->getdata().tostring() + ")";
    for (treenode* child : node->getchildren()) {
        printrecursive(child, depth + 1);
    }
}

main.cpp

#include <qcoreapplication>
#include "tree.h"

int main(int argc, char* argv[]) {
    qcoreapplication a(argc, argv);

    // 创建树
    tree tree;

    // 创建子节点，明确传入父节点
    treenode* nodea = tree.addnode(nullptr, tc("节点a")); // 默认添加到根节点
    treenode* nodeb = tree.addnode(nodea, tc("节点b"));
    treenode* nodec = tree.addnode(nodea, tc("节点c"));

    // 添加数据
    tree.setnodedata(nodea, tc("温度过高"));
    tree.setnodedata(nodeb, tc("正常"));
    tree.setnodedata(nodec, tc("压力过低"));

    // 获取数据
    qdebug() << tc("节点a数据:") << tree.getnodedata(nodea).tostring();

    // 清除数据
    tree.clearnodedata(nodec);

    // 过滤节点
    qlist<treenode*> filterednodes = tree.filternodes(tc("温度"));
    qdebug() << tc("过滤结果:");
    for (treenode* node : filterednodes) {
        qdebug() << node->getname() << ":" << node->getdata().tostring();
    }

    // 打印树结构
    tree.printtree();

    return a.exec();
}

运行结果

成功初始化根节点。
未指定父节点，默认添加到根节点。
未指定父节点，默认添加到根节点。
未指定父节点，默认添加到根节点。
节点a数据: "温度过高"
过滤结果:
"节点a" : "温度过高"
根节点 ()
节点a (温度过高)
节点b (正常)
节点c ()

功能总结

该实现支持树节点的添加、删除、查询、过滤，以及节点数据的设置、获取、清除。同时，包含中文提示与日志输出，逻辑健壮且易于扩展。

到此这篇关于基于qt实现的自定义树结构容器的文章就介绍到这了,更多相关qt自定义树结构容器内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

基于Qt实现的自定义树结构容器

2024年12月03日 • C/C++ •我要评论