QT的Model-View实现大批量数据展示

最新推荐文章于 2024-08-09 00:25:48 发布
最新推荐文章于 2024-08-09 00:25:48 发布
阅读量406 收藏 15
点赞数 10
文章标签： qt 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38220144/article/details/141020705
版权

一、完整源代码

1.项目结构

2.各文件代码展示

define.h

#pragma once
#include <QVector>

//学生信息
typedef struct _STUDENT {
    QString name;   //姓名
    int score1;     //语文成绩
    int score2;     //数学成绩
    int score3;     //外语成绩
    _STUDENT()
    {
        name = "";
        score1 = score2 = score3 = 0;
    }
}STUDENT, *PSTUDENT;

//班级信息
typedef struct _CLASS {
    QString name;   //班级
    QVector<STUDENT*> students;
    _CLASS()
    {
        name = "";
    }
}CLASS;

mainwindow.h

#pragma once

#include <QtWidgets/QWidget>
#include "ui_mainwindow.h"
#include "define.h"

class TreeModel;
class TreeItem;

class MainWindow : public QWidget
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = Q_NULLPTR);


private slots:
    void on_btn1_clicked(); //QStandardItemModel
    void on_btn2_clicked(); //自定义model
    void SlotItemSelect(const QModelIndex &modelIndex);
    void SlotAddItem();
    void SlotRightMenu(const QPoint &pos);
    void SlotTreeMenuDelete();

private:
    Ui::MainWindowClass *ui;
    QVector<CLASS*> mClasses;   //模拟数据
    TreeModel *model;
};

mainwindow.cpp

#include "mainwindow.h"
#include "TreeItem.h"
#include "TreeModel.h"

#include <QMenu>
#include <QTreeView>
#include <QStandardItemModel>
#include <QStandardItem>
#include <QItemSelectionModel>

MainWindow::MainWindow(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::MainWindowClass())
{
    ui->setupUi(this);
    //初始化模拟数据：学生成绩
    //10个班级、每个班级10000个学生，共10W行记录
    int nClass = 10;
    int nStudent = 100000;
    for (int i = 0; i < nClass; i++)
    {
        CLASS* c = new CLASS;
        c->name = QString("class%1").arg(i);
        for (int j = 0; j < nStudent; j++)
        {
            STUDENT* s = new STUDENT;
            s->name = QString("name%1").arg(j);
            s->score1 = s->score2 = s->score3 = (j % 10) * 10;
            c->students.append(s);
        }
        mClasses.append(c);
    }
    connect(ui->btn1, &QPushButton::clicked, this, &MainWindow::on_btn1_clicked);
    connect(ui->btn2, &QPushButton::clicked, this, &MainWindow::on_btn2_clicked);
    connect(ui->treeView, &QTreeView::clicked, this, &MainWindow::SlotItemSelect);
    connect(ui->pushButton, &QPushButton::clicked, this, &MainWindow::SlotAddItem);
    connect(ui->treeView, &QTreeView::customContextMenuRequested, this, &MainWindow::SlotRightMenu);
    ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
}

void MainWindow::on_btn1_clicked()
{
    //1，QTreeView常用设置项
    QTreeView* t = ui->treeView;
    //    t->setEditTriggers(QTreeView::NoEditTriggers);			//单元格不能编辑
    t->setSelectionBehavior(QTreeView::SelectRows);			//一次选中整行
    t->setSelectionMode(QTreeView::SingleSelection);        //单选，配合上面的整行就是一次选单行
//    t->setAlternatingRowColors(true);                       //每间隔一行颜色不一样，当有qss时该属性无效
    t->setFocusPolicy(Qt::NoFocus);                         //去掉鼠标移到单元格上时的虚线框

    //2，列头相关设置
    t->header()->setHighlightSections(true);                //列头点击时字体变粗，去掉该效果
    t->header()->setDefaultAlignment(Qt::AlignCenter);      //列头文字默认居中对齐
    t->header()->setDefaultSectionSize(100);                //默认列宽100
    t->header()->setStretchLastSection(true);               //最后一列自适应宽度
    t->header()->setSortIndicator(0, Qt::AscendingOrder);    //按第1列升序排序
    //3，构造Model
    QStringList headers;
    headers << QStringLiteral("班级/姓名")
        << QStringLiteral("语文")
        << QStringLiteral("数学")
        << QStringLiteral("外语")
        << QStringLiteral("总分")
        << QStringLiteral("平均分")
        << QStringLiteral("是否合格")
        << QStringLiteral("是否评优");
    QStandardItemModel* model = new QStandardItemModel(ui->treeView);
    model->setHorizontalHeaderLabels(headers);
    foreach(CLASS* c, mClasses)
    {
        QStandardItem *pItemClass = new QStandardItem(c->name);
        model->appendRow(pItemClass);
        foreach(STUDENT* s, c->students)
        {
            //二级节点：学生信息
            int score1 = s->score1;
            int score2 = s->score2;
            int score3 = s->score3;
            int nTotal = score1 + score2 + score3;
            int nAverage = nTotal / 3;
            bool bPass = true;
            if (score1 < 60 || score2 < 60 || score3 < 60)
            {
                //任意一门课不合格则不合格
                bPass = false;
            }
            bool bGood = false;
            if (score1 >= 90 && score2 >= 90 && score3 >= 90)
            {
                //每门课都达到90分以上评优
                bGood = true;
            }

            QList<QStandardItem*> items;
            QStandardItem* item0 = new QStandardItem(s->name);
            QStandardItem* item1 = new QStandardItem(QString::number(score1));
            QStandardItem* item2 = new QStandardItem(QString::number(score2));
            QStandardItem* item3 = new QStandardItem(QString::number(score3));
            QStandardItem* item4 = new QStandardItem(QString::number(nTotal));
            QStandardItem* item5 = new QStandardItem(QString::number(nAverage));
            QStandardItem* item6 = new QStandardItem(bPass ? QStringLiteral("合格") : QStringLiteral("不合格"));
            QStandardItem* item7 = new QStandardItem(bGood ? QStringLiteral("优秀") : QStringLiteral("-"));
            items << item0 << item1 << item2 << item3 << item4 << item5 << item6 << item7;
            pItemClass->appendRow(items);
        }
    }
    t->setModel(model);
}

void MainWindow::on_btn2_clicked()
{
    //1，QTreeView常用设置项
    QTreeView* t = ui->treeView;
    //    t->setEditTriggers(QTreeView::NoEditTriggers);			//单元格不能编辑
    t->setSelectionBehavior(QTreeView::SelectRows);			//一次选中整行
    t->setSelectionMode(QTreeView::SingleSelection);        //单选，配合上面的整行就是一次选单行
//    t->setAlternatingRowColors(true);                       //每间隔一行颜色不一样，当有qss时该属性无效
    t->setFocusPolicy(Qt::NoFocus);                         //去掉鼠标移到单元格上时的虚线框

    //2，列头相关设置
    t->header()->setHighlightSections(true);                //列头点击时字体变粗，去掉该效果
    t->header()->setDefaultAlignment(Qt::AlignCenter);      //列头文字默认居中对齐
    t->header()->setDefaultSectionSize(100);                //默认列宽100
    t->header()->setStretchLastSection(true);               //最后一列自适应宽度
    t->header()->setSortIndicator(0, Qt::AscendingOrder);    //按第1列升序排序
    //3，构造Model
    QStringList headers;
    headers << QStringLiteral("班级/姓名")
        << QStringLiteral("语文")
        << QStringLiteral("数学")
        << QStringLiteral("外语")
        << QStringLiteral("总分")
        << QStringLiteral("平均分")
        << QStringLiteral("是否合格")
        << QStringLiteral("是否评优");
    model = new TreeModel(headers, ui->treeView);
    TreeItem *pRootItem = model->root();
    foreach(CLASS* c, mClasses)
    {
        TreeItem *pClass = new TreeItem(pRootItem);
        pClass->setLevel(1);
        pClass->setPtr(c);
        pRootItem->appendChild(pClass);
        foreach(STUDENT* s, c->students)
        {
            TreeItem* itemStudent = new TreeItem(pClass);
            itemStudent->setLevel(2);   //设为一级节点，供显示时判断节点层级来转换数据指针类型
            itemStudent->setPtr(s);     //保存STUDENT* s为其数据指针，显示时从STUDENT*取内容显示
            pClass->appendChild(itemStudent);
        }
    }
    t->setModel(model);
}

void MainWindow::SlotItemSelect(const QModelIndex &modelIndex)
{
    TreeItem *pItem = static_cast<TreeItem*>(modelIndex.internalPointer());

    QString strText = QString::number(pItem->level());
    strText += "\n" + QString::number(pItem->row());
    ui->plainTextEdit->setPlainText(strText);
}

void MainWindow::SlotAddItem()
{
    QItemSelectionModel *pSelectionModel = ui->treeView->selectionModel();
    if (pSelectionModel->hasSelection()) {
        // 获取选中的索引列表
        QModelIndexList selectedIndexes = pSelectionModel->selectedIndexes();

        // 一般情况下，QTreeView 是单选，所以可以直接获取第一个选中的索引
        QModelIndex selectedIndex = selectedIndexes.first();
        // 如果需要处理特定列的数据，可以通过 QModelIndex 访问模型中的数据
        //QVariant data = selectedIndex.data(Qt::DisplayRole);
        TreeItem *pItem = static_cast<TreeItem*>(selectedIndex.internalPointer());
        TreeItem *pParentItem = pItem->parentItem();
        STUDENT* s = new STUDENT;
        s->name = QString("name10086");
        s->score1 = s->score2 = s->score3 = 10086;
        TreeItem *pAddItem = new TreeItem(pParentItem);
        pAddItem->setPtr(s);
        pAddItem->setLevel(2);
        pParentItem->appendChild(pAddItem);
        ui->treeView->setModel(model);
        // 方法1，递归方法
        //QModelIndex pParentIndex = model->indexOfItem(pParentItem);
        // 方法2，通过createIndex
        QModelIndex pParentIndex = model->indexFromItem(pParentItem);
        ui->treeView->collapse(pParentIndex);
        ui->treeView->expand(pParentIndex);
    }
}

void MainWindow::SlotRightMenu(const QPoint &pos)
{
    //创建右键菜单
    QMenu menu;

    //添加action
    QAction *actionDelete = new QAction(QStringLiteral("删除"));
    menu.addAction(actionDelete);
    connect(actionDelete, &QAction::triggered, this, &MainWindow::SlotTreeMenuDelete);
    menu.exec(ui->treeView->viewport()->mapToGlobal(pos));
}

void MainWindow::SlotTreeMenuDelete()
{
    QItemSelectionModel *pSelectionModel = ui->treeView->selectionModel();
    if (pSelectionModel->hasSelection())
    {
        QModelIndexList selectedIndexes = pSelectionModel->selectedIndexes();
        QModelIndex selectedIndex = selectedIndexes.first();
        TreeItem *pItem = static_cast<TreeItem*>(selectedIndex.internalPointer());
        TreeItem *pParentItem = pItem->parentItem();
        pParentItem->removeChild(pItem->row());
        for (int i = 0; i < pParentItem->getChildList().size(); i++)
        {
            TreeItem *pItemTemp = pParentItem->getChildList().at(i);
            pItemTemp->setRow(i);
        }
        QModelIndex pParentIndex = model->indexFromItem(pParentItem);
        ui->treeView->collapse(pParentIndex);
        ui->treeView->expand(pParentIndex);
    }
}

TreeItem.h

#pragma once
#include <QVariant>
#include <QList>
class TreeItem
{
public:
    explicit TreeItem(TreeItem *parentItem = nullptr);
    ~TreeItem();
    int childCount() const;                 //子节点计数
    int row() const;                        //获取该节点是父节点的第几个子节点
    void appendChild(TreeItem *item);
    void removeChild(int index);
    QList<TreeItem*> getChildList();
    TreeItem *parentItem();                 //获取父节点指针
    TreeItem *child(int row);               //获取第row个子节点指针
    
    //核心函数：获取节点第column列的数据
    QVariant data(int column) const;

    //设置、获取节点是几级节点（就是树的层级）
    int level() { return m_nLevel; }
    void setLevel(int level) { m_nLevel = level; }

    //设置、获取节点存的数据指针
    void setPtr(void* p) { m_pPtr = p; }
    void* ptr() { return m_pPtr; }

    //保存该节点是其父节点的第几个子节点，查询优化所用
    void setRow(int row) {
        m_nRow = row;
    }

private:
    TreeItem *m_pParentItem;
    QList<TreeItem*> m_listChildItems;
    int m_nLevel;
    void *m_pPtr;
    int m_nRow;

};

TreeItem.cpp

#include "TreeItem.h"
#include "define.h"
TreeItem::TreeItem(TreeItem *parentItem /*= nullptr*/)
{
    m_pParentItem = parentItem;
}

TreeItem::~TreeItem()
{

}

int TreeItem::childCount() const
{
    return m_listChildItems.count();
}

int TreeItem::row() const
{
    return m_nRow;
}

void TreeItem::appendChild(TreeItem *item)
{
    item->setRow(m_listChildItems.size());   //item存自己是第几个，可以优化效率
    m_listChildItems.append(item);
}

void TreeItem::removeChild(int index)
{
    delete m_listChildItems.takeAt(index); // 删除并释放元素的内存
}

QList<TreeItem*> TreeItem::getChildList()
{
    return m_listChildItems;
}

TreeItem * TreeItem::parentItem()
{
    return m_pParentItem;
}

TreeItem * TreeItem::child(int row)
{
    return m_listChildItems.value(row);
}

QVariant TreeItem::data(int column) const
{
    if (m_nLevel == 1)
    {
        //一级节点，班级
        if (column == 0)
        {
            CLASS* c = (CLASS*)m_pPtr;
            return c->name;
        }
    }
    else if (m_nLevel == 2)
    {
        //二级节点学生信息
        STUDENT* s = (STUDENT*)m_pPtr;
        switch (column)
        {
        case 0: return s->name;
        case 1: return QString::number(s->score1);
        case 2: return QString::number(s->score2);
        case 3: return QString::number(s->score3);
        case 4: return QString::number(s->score1 + s->score2 + s->score3);
        case 5: return QString::number((s->score1 + s->score2 + s->score3) / 3);
        case 6:
        {
            if (s->score1 < 60 || s->score2 < 60 || s->score3 < 60)
            {
                //任意一门课不合格则不合格
                return QStringLiteral("不合格");
            }
            else
            {
                return QStringLiteral("合格");
            }
        }
        case 7:
        {
            if (s->score1 >= 90 && s->score2 >= 90 && s->score3 >= 90)
            {
                //每门课都达到90分以上评优
                return QStringLiteral("优秀");
            }
            else
            {
                return QStringLiteral("-");
            }
        }
        default:
            return QVariant();
        }
    }
    return QVariant();
}

TreeModel.h

#pragma once
#include "TreeItem.h"
#include <QAbstractItemModel>
class TreeModel : public QAbstractItemModel
{
    Q_OBJECT
public:
    explicit TreeModel(QStringList headers,QObject *parent = nullptr);
    ~TreeModel();
    //以下为自定义model需要实现的一些虚函数，将会被Qt在查询model数据时调用
    //headerData: 获取表头第section列的数据
    //data: 核心函数，获取某个索引index的元素的各种数据
    //      role决定获取哪种数据，常用有下面几种：
    //      DisplayRole（默认）：就是界面显示的文本数据
    //      TextAlignmentRole：就是元素的文本对齐属性
    //      TextColorRole、BackgroundRole：分别指文本颜色、单元格背景色
    //flags: 获取index的一些标志，一般不怎么改
    //index: Qt向你的model请求一个索引为parent的节点下面的row行column列子节点的元素，在本函数里你需要返回该元素的正确索引
    //parent：获取指定元素的父元素
    //rowCount: 获取指定元素的子节点个数（下一级行数）
    //columnCount: 获取指定元素的列数
    Qt::ItemFlags flags(const QModelIndex &index) const override;
    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
    QModelIndex parent(const QModelIndex &child) const override;
    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent = QModelIndex()) const override;

public:
    TreeItem *itemFromIndex(const QModelIndex &index) const;
    QModelIndex indexFromItem(const TreeItem *item) const;
    QModelIndex indexOfItem(TreeItem *item) const;
    QModelIndex recursiveIndexSearch(TreeItem *currentItem, TreeItem *targetItem) const;
    TreeItem *root();

private:
    QStringList m_listHeaders;
    TreeItem *m_pRootItem;
};

TreeModel.cpp

#include "TreeModel.h"

TreeModel::TreeModel(QStringList headers, QObject *parent /*= nullptr*/):QAbstractItemModel(parent)
{
    m_listHeaders = headers;
    m_pRootItem = new TreeItem;
}

TreeModel::~TreeModel()
{

}

Qt::ItemFlags TreeModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
    {
        return 0;
    }
    return QAbstractItemModel::flags(index);
}

// 返回表头第section列的数据
QVariant TreeModel::headerData(int section, Qt::Orientation orientation, int role /*= Qt::DisplayRole*/) const
{
    if (orientation == Qt::Horizontal)
    {
        if (role == Qt::DisplayRole)
        {
            return m_listHeaders.at(section);
        }
    }
    return QVariant();
}

QVariant TreeModel::data(const QModelIndex &index, int role /*= Qt::DisplayRole*/) const
{
    if (!index.isValid())
    {
        return QVariant();
    }

    TreeItem *item = static_cast<TreeItem*>(index.internalPointer());
    if (role == Qt::DisplayRole)
    {
        return item->data(index.column());
    }
    return QVariant();
}

QModelIndex TreeModel::index(int row, int column, const QModelIndex &parent /*= QModelIndex()*/) const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();
    TreeItem *parentItem;
    if (!parent.isValid())
    {
        parentItem = m_pRootItem;
    }
    else
    {
        parentItem = static_cast<TreeItem *>(parent.internalPointer());
    }
    TreeItem *pChildItem = parentItem->child(row);
    if (pChildItem)
    {
        return createIndex(row,column,pChildItem);
    }
    else
    {
        return QModelIndex();
    }
}

QModelIndex TreeModel::parent(const QModelIndex &child) const
{
    if (!child.isValid())
        return QModelIndex();
    TreeItem *childItem = static_cast<TreeItem*>(child.internalPointer());
    TreeItem *parentItem = childItem->parentItem();
    if (parentItem == m_pRootItem)
        return QModelIndex();
    return createIndex(parentItem->row(), 0, parentItem);
}

int TreeModel::rowCount(const QModelIndex &parent /*= QModelIndex()*/) const
{
    TreeItem *parentItem;
    if (parent.column() > 0)
        return 0;

    if (!parent.isValid())
        parentItem = m_pRootItem;
    else
        parentItem = static_cast<TreeItem*>(parent.internalPointer());

    return parentItem->childCount();
}

int TreeModel::columnCount(const QModelIndex &parent /*= QModelIndex()*/) const
{
    return m_listHeaders.size();;
}

TreeItem * TreeModel::itemFromIndex(const QModelIndex &index) const
{
    if (!index.isValid())
        return nullptr;
    TreeItem *item = static_cast<TreeItem *>(index.internalPointer());
    return item;
}

QModelIndex TreeModel::indexFromItem(const TreeItem *item) const
{
    TreeItem *pItem = const_cast<TreeItem *>(item);
    if (pItem->parentItem() == m_pRootItem)
    {
        return createIndex(pItem->row(), 0, pItem);
    }
    return QModelIndex();
}

QModelIndex TreeModel::indexOfItem(TreeItem *item) const
{
    // 如果模型是树形结构，可以递归遍历查找
    return recursiveIndexSearch(m_pRootItem, item);
}

QModelIndex TreeModel::recursiveIndexSearch(TreeItem *currentItem, TreeItem *targetItem) const
{
    if (currentItem == targetItem) {
        // 如果找到了目标项，返回其索引
        return createIndex(currentItem->row(), 0, currentItem);
    }

    // 递归搜索子项
    for (int i = 0; i < currentItem->childCount(); ++i) {
        QModelIndex idx = recursiveIndexSearch(currentItem->child(i), targetItem);
        if (idx.isValid()) {
            return idx;
        }
    }

    return QModelIndex();
}

TreeItem * TreeModel::root()
{
    return m_pRootItem;
}

3.界面


二、重要部分代码解释

1.TreeModel.cpp

在TreeMode中，最重要的是data()函数，该函数决定数据是否能够直接在View层进行显示。该接口中的QModelIndex是树中哪个结点下哪一行哪一列的索引（Model-View主要依赖于QModelIndex来取数据显示）。QModelIndex详解看：QT模型视图MVC系列教程（2）-模型数据索引QModelIndex详解-CSDN博客

QVariant TreeModel::data(const QModelIndex &index, int role /*= Qt::DisplayRole*/) const
{
    if (!index.isValid())
    {
        return QVariant();
    }

    TreeItem *item = static_cast<TreeItem*>(index.internalPointer());
    if (role == Qt::DisplayRole)
    {
        return item->data(index.column());
    }
    return QVariant();
}
2.TreeItem.cpp

TreeItem是自定义的一个item类，也就是树中显示的每一行数据在Model中的存储。View层会通过data函数来取要显示的数据。比如TreeModel::data中的return item->data(index.column());

QVariant TreeItem::data(int column) const
{
    if (m_nLevel == 1)
    {
        //一级节点，班级
        if (column == 0)
        {
            CLASS* c = (CLASS*)m_pPtr;
            return c->name;
        }
    }
    else if (m_nLevel == 2)
    {
        //二级节点学生信息
        STUDENT* s = (STUDENT*)m_pPtr;
        switch (column)
        {
        case 0: return s->name;
        case 1: return QString::number(s->score1);
        case 2: return QString::number(s->score2);
        case 3: return QString::number(s->score3);
        case 4: return QString::number(s->score1 + s->score2 + s->score3);
        case 5: return QString::number((s->score1 + s->score2 + s->score3) / 3);
        case 6:
        {
            if (s->score1 < 60 || s->score2 < 60 || s->score3 < 60)
            {
                //任意一门课不合格则不合格
                return QStringLiteral("不合格");
            }
            else
            {
                return QStringLiteral("合格");
            }
        }
        case 7:
        {
            if (s->score1 >= 90 && s->score2 >= 90 && s->score3 >= 90)
            {
                //每门课都达到90分以上评优
                return QStringLiteral("优秀");
            }
            else
            {
                return QStringLiteral("-");
            }
        }
        default:
            return QVariant();
        }
    }
    return QVariant();
}

罚酒饮得
关注
  • 10
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Qt Model/View 实现Model类参考工程
12-24
在Qt框架中，Model/View编程模式是一种强大的机制，用于处理数据展示和用户交互。它将数据模型（Model）与视图（View）和控制器（Controller）分离，使得数据的管理与界面显示相独立，提高了代码的可复用性和可维护...
Qt-Model-View-学习笔记.pdf
11-17
在Qt的实现中，Model提供了数据接口，View负责渲染数据，Delegate则允许自定义数据项的显示和编辑行为。 **Model组件** 所有item models都继承自`QAbstractItemModel`，该类定义了一个通用接口，使得View和...
基于QT - SOCKET 的 C++ 实现矩阵压力数据采集及压力云图现实。.zip
12-28
基于QT - SOCKET 的 C++ 实现矩阵压力数据采集及压力云图现实。 基于QT - SOCKET 的 C++ 实现矩阵压力数据采集及压力云图现实。 基于QT - SOCKET 的 C++ 实现矩阵压力数据采集及压力云图现实。 基于QT - SOCKET 的 ...
QT Model/View 编程官方教程实例
09-14
按官方文档实现QT Model/View 编程，Qt包含一组项视图类，这些类使用模型/视图体系结构来管理数据和数据呈现给用户的方式之间的关系。该体系结构引入的功能分离为开发人员提供了更大的灵活性来定制项的表示，并提供...
QTableView使用示例-Qt模型视图代理（Model-View-Delegate）使用示例
08-05
本实例基于QT的委托代理机制实现的Qt模型视图代理（Model-View-Delegate）使用示例。以QTableView为基础，实现表头排序，列表复选框，插入按钮、下拉框、进度条。 模型视图委托（MVD）是Qt中特有的设计模式，类似MVC...
(Qt) QThread 信号槽所在线程
cuber-lotus的博客
08-08 738
在 Qt 中用一套自己的封装的多线程操作。其中一种方式是继承 QThread 并实现void run();方法使用启动，这是一种很常见的线程的封装方式。这种方式在 java 中也是这么设计的。但是由于 Qt 的高度封装性和框架整体性，很多特性都是开发者自己测试出来的。其中 QThread 配合信号槽的特性就是本文要观察的重点。
Qt使用lupdate工具生成.ts文件
弘毅_hao的博客
08-08 190
Qt ts翻译源文件的生成
贪吃蛇（使用QT）
qq_63168095的博客
08-03 1317
贪吃蛇游戏是⼀款休闲益智类游戏。它通过控制蛇头方向吃食物，从而使得蛇变得越来越长。在本游戏中设置了上下左右四个⽅向键来控制蛇的移动方向。⻝物的产⽣是随机⽣成的，当蛇每吃⼀次⻝物就会增加⼀节身体，同时游戏积分也会相应的加⼀。在本游戏的设计中，蛇的⾝体会越吃越长，身体越长对应的难度就越⼤，因为⼀旦蛇头和⾝体相交游戏就会结束。贪吃蛇项目地址。
Qt 将生成的exe文件自动复制到其它目录下
weixin_51883798的博客
08-07 236
这部分代码用于复制原始exe到 "G:\test\build\test\"这句代码实现：把TargetEXE复制到OutputDir目录下。此时，我希望在生成该exe文件时，此目录下也可生成该exe文件。
QT生成.exe文件无法在未安装QT的电脑上运行的解决办法
nownow_的博客
08-07 243
The application failed to start because no Qt platform plugin could be initialized
QT：QString 支持 UTF-8 编码吗？
程序猿视角
08-08 63
在这种情况下，Qt 提供了丰富的转换函数，可以将 QString 转换为各种编码格式的字节序列，包括 UTF-8。同样，当需要从外部系统接收数据时，可以使用 QString::fromUtf8()、QString::fromLatin1() 等静态函数将字节序列转换回 QString。在 Qt 中，字符串的处理主要依赖于 QString 类。虽然 QString 内部不是以 UTF-8 编码存储字符串，但 Qt 提供了灵活的转换机制，允许在需要时轻松地在 UTF-8 和 QString 之间进行转换。
QT容器组
最新发布
2301_82087113的博客
08-09 427
QT容器组
QT 跨平台检测断网，检测锁屏，检测睡眠，检测屏保功能
cs821984831的博客
08-08 124
跨平台检测断网，检测睡眠，检测屏保，检测锁屏
Qt实现类似淘宝商品看板的界面，带有循环翻页以及点击某页跳转的功能
m0_59119702的博客
08-08 193
Qt实现类似淘宝商品看板的界面
【Qt】容器类控件
m0_72563041的博客
08-08 470
【Qt】QGroupBox&QTabWidget
QT实现接收JSON格式的UDP数据并解析
qq_38220144的博客
08-08 140
【代码】QT实现接收JSON格式的UDP数据并解析。
[MIT6.5840]Lab3A leader election
天道酬勤，厚积薄发
08-08 572
lab3A leader election
简单Qt贪吃蛇项目
m0_67457606的博客
08-08 505
贪吃蛇游戏是⼀款休闲益智类游戏。它通过控制蛇头⽅向吃⻝物，从⽽使得蛇变得越来越⻓。在本游戏中设置了上下左右四个⽅向键来控制蛇的移动⽅向。⻝物的产⽣是随机⽣成的，当蛇每吃⼀次⻝物就会增加⼀节⾝体，同时游戏积分也会相应的加⼀。在本游戏的设计中，蛇的⾝体会越吃越⻓，⾝体越⻓对应的难度就越⼤，因为⼀旦蛇头和⾝体相交游戏就会结束。界面一：游戏大厅界面当用户点击 “开始游戏” 按钮之后，就会进⼊到关卡选择界面。界面二：关卡选择界面在关卡选择界⾯上设置了三个游戏模式按钮，分别是：简单模式、正常模式、困难模式；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值