Day 30：模型-视图架构（Model-View Architecture）

模型-视图架构（Model-View Architecture）：把"数据的持有与变更"和"数据的呈现与交互"拆成两个互不认识的协作方，中间只靠一套约定好的查询与通知协议同步——模型回答"你有多少行、多少列、第 r 行第 c 列在某个角色下是什么值"，视图负责"把这些值画到屏幕上并接收鼠标键盘"，代理模型负责"换个角度看成什么样（排序/筛选/分组）"，委托负责"单个格子怎么画、怎么编辑"。Qt 把这套协议固化成了可组合的基础设施，于是"一份数据、多种视图、任意排序筛选"不再需要你写重复代码。

假设你要做一个"我的音乐库"窗口，最直觉的写法是直接用 QTableWidget，把数据一条条塞进单元格里：

// ❌ 坏味道：数据、业务规则、渲染、导出全部糊在 MainWindow 里
void MainWindow::loadSongs()
{
    ui->tableWidget->setRowCount(4);
    const QStringList titles{ "City of Stars", "Yesterday",
                              "Bohemian Rhapsody", "Imagine" };
    const QList<int> ratings{ 5, 4, 5, 3 };
    for (int i = 0; i < titles.size(); ++i) {
        ui->tableWidget->setItem(i, 0, new QTableWidgetItem(titles[i]));
        // 评分明明是 int，却被迫变成字符串存进单元格
        ui->tableWidget->setItem(i, 1, new QTableWidgetItem(QString::number(ratings[i])));
    }
    // 点表头排序 —— 把字符串当数字排，得到 "3","4","5" 看着对，
    // 一旦评分变成 "9" 和 "100"，顺序就彻底错了：'1' < '9'
    ui->tableWidget->sortItems(1, Qt::DescendingOrder);
}

// 想导出 CSV？只能反向遍历 widget，把 UI 当成数据库读
void MainWindow::exportCsv(const QString& path)
{
    QFile f(path);
    f.open(QIODevice::WriteOnly);
    for (int r = 0; r < ui->tableWidget->rowCount(); ++r) {
        QStringList row;
        for (int c = 0; c < ui->tableWidget->columnCount(); ++c)
            row << ui->tableWidget->item(r, c)->text();
        // 如果某一格是 nullptr（比如被跳过没填），这里直接崩溃
        f.write((row.join(',') + "\n").toUtf8());
    }
}

这段代码的问题，逐个说清楚：

1. 数据的唯一真相变成了 widget。UI 的生命周期等于数据的生命周期：窗口关掉，数据就没了；想做"撤销"，你得从 UI 反读回来。
2. 数据取不出来。要导出 CSV、要把同一份数据喂给图表、要换成 QML 界面，你都只能遍历 QTableWidgetItem——而它本来是为显示服务的私有存储。
3. 排序/筛选语义失控。sortItems 用的是"显示文本"的字典序，数字列被当成字符串排，这是最经典的隐性 bug。
4. 性能随行数爆炸。每个单元格背后是一个 QTableWidgetItem、可能还有一个编辑用 QWidget。10 万行日志会吃掉几百 MB 内存和好几秒构建时间。而模型-视图下视图只为"可见的那几十行"调用 data()。
5. 无法单元测试。业务规则（评分必须在 0~5）散落在 cell 赋值和事件处理里，想测它必须先创建一个 GUI。

模型-视图架构的整个思想，可以压缩成"模型只回答四个问题，别的什么都不做"：

① 你有多少行？多少列？（rowCount() / columnCount()）
② 第 r 行第 c 列，在"某个角色"下是什么值？（data(index, role)）——注意"角色"这个设计：同一份数据，给显示用是文本，给编辑用是原始值，给排序用可能是数值，给委托用可能是自定义语义。
③ 表头叫什么？（headerData()）
④ 用户改了一个值，写回去。（setData()，写入成功后发信号通知。）

视图只做一件相反的事：把模型"拉"出来的数据画到屏幕上，并把用户的鼠标键盘事件"翻译"成对模型的查询或写回。视图里不该有业务规则，模型里不该出现任何绘制代码。

Qt 的模型-视图不是"两个类"，而是四层协作 + 一个值对象索引。关系如下（文字版结构图）：

                    ┌───────────────────────────────┐
                    │     QAbstractItemModel        │   数据真相（接口）
                    │  rowCount / columnCount       │
                    │  data(index, role)            │
                    │  dataChanged / rowsInserted ──┼──▶ 信号：通知视图
                    └───────────────▲───────────────┘
                          ▲         │ 继承
        继承              │         ├── QStandardItemModel     （通用容器实现，适合原型）
   ┌─────────────────────┴──┐      ├── QFileSystemModel       （文件系统即数据源）
   │  QAbstractProxyModel   │      └── SongModel / LogModel    （你的业务模型）
   │  QSortFilterProxyModel │──引用──▶ 源 Model（源数据一个字节都不改）
   └───────────┬────────────┘
               │ 被 setModel() 引用（视图只认识"模型接口"）
               ▼
   ┌────────────────────────────────────────────┐
   │        QAbstractItemView                   │  几何 + 交互状态
   │  QTableView / QTreeView / QListView /      │  滚动、选中、展开、编辑触发策略
   │  QColumnView / QComboBox（内部也用）        │
   └───────────────────┬────────────────────────┘
                       │ setItemDelegateForColumn / setItemDelegate
                       ▼
   ┌────────────────────────────────────────────┐
   │   QStyledItemDelegate（QAbstractItemDelegate）│ 单格呈现 + 编辑
   │   paint() / sizeHint() / createEditor() /   │
   │   setEditorData() / setModelData()          │
   └────────────────────────────────────────────┘

各角色的职责边界（背下来，这是面试区分度最高的部分）：

先用纯 C++17 把这套骨架跑通——理解了它，Qt 的那一堆类只是把同样的接口换成了 QModelIndex 版本。这段代码可以直接编译：

// demo_model_view.cpp —— 纯 C++17，不依赖 Qt
// 编译 & 运行： g++ -std=c++17 -O2 -o demo demo_model_view.cpp && ./demo
#include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>

// ============ Model 接口：只回答"有多少行/列、取什么值" ============
class IModel {
public:
    virtual ~IModel() = default;
    virtual int rowCount() const = 0;
    virtual int columnCount() const = 0;
    virtual std::string header(int column) const = 0;
    virtual std::string data(int row, int column) const = 0;
};

// ============ 具体 Model：持有数据，别的什么都不做 ============
class SongModel final : public IModel {
public:
    struct Song { std::string title; int rating; };   // 业务数据结构，与 UI 无关

    void addSong(std::string title, int rating) {
        songs_.push_back(Song{std::move(title), rating});
        // 真实 Qt 实现里，这里前后要包 beginInsertRows / endInsertRows
    }

    int rowCount() const override { return static_cast<int>(songs_.size()); }
    int columnCount() const override { return 2; }

    std::string header(int column) const override {
        return column == 0 ? "歌名" : "评分";
    }

    std::string data(int row, int column) const override {
        const Song& s = songs_.at(static_cast<std::size_t>(row));
        return column == 0 ? s.title : std::to_string(s.rating);
    }

private:
    std::vector<Song> songs_;   // 数据在这里，视图看不见它
};

// ============ 代理 Model：包装另一个 Model，不改源数据一个字节 ============
class SortProxy final : public IModel {
public:
    explicit SortProxy(const IModel& source) : source_(source) {
        order_.resize(static_cast<std::size_t>(source_.rowCount()));
        std::iota(order_.begin(), order_.end(), 0);   // 初始顺序 = 源顺序
    }

    // 只重排"行号映射表"，源数据依然是原始插入顺序
    void sortBy(int column, bool ascending) {
        std::stable_sort(order_.begin(), order_.end(),
                         [this, column, ascending](int a, int b) {
                             return ascending ? lessThan(a, b, column)
                                              : lessThan(b, a, column);
                         });
    }

    int rowCount() const override { return source_.rowCount(); }
    int columnCount() const override { return source_.columnCount(); }
    std::string header(int column) const override { return source_.header(column); }
    std::string data(int row, int column) const override {
        return source_.data(order_.at(static_cast<std::size_t>(row)), column);
    }

private:
    bool lessThan(int a, int b, int column) const {
        if (column == 1)   // 关键：评分列按"数值"比，避免 "9" > "100" 的字典序陷阱
            return std::stoi(source_.data(a, column)) < std::stoi(source_.data(b, column));
        return source_.data(a, column) < source_.data(b, column);
    }

    const IModel& source_;         // 不拥有数据，只引用
    std::vector<int> order_;        // 索引映射表：视图行号 -> 源行号
};

// ============ View 接口：只负责"怎么呈现" ============
class IView {
public:
    virtual ~IView() = default;
    virtual void render(const IModel& model, const std::string& title) const = 0;
};

// 视图 A：控制台友好格式
class ConsoleView final : public IView {
public:
    void render(const IModel& model, const std::string& title) const override {
        std::cout << "=== " << title << " ===\n";
        for (int r = 0; r < model.rowCount(); ++r)
            std::cout << model.data(r, 0) << " (" << model.data(r, 1) << ")\n";
        std::cout << '\n';
    }
};

// 视图 B：CSV 导出格式 —— 同一个 Model，完全不同的呈现，零改动 Model
class CsvView final : public IView {
public:
    void render(const IModel& model, const std::string& title) const override {
        std::cout << "=== " << title << " ===\n";
        for (int c = 0; c < model.columnCount(); ++c)
            std::cout << model.header(c) << (c + 1 == model.columnCount() ? '\n' : ',');
        for (int r = 0; r < model.rowCount(); ++r) {
            for (int c = 0; c < model.columnCount(); ++c)
                std::cout << model.data(r, c)
                          << (c + 1 == model.columnCount() ? '\n' : ',');
        }
        std::cout << '\n';
    }
};

int main() {
    SongModel model;                       // 唯一的数据真相
    model.addSong("Yesterday", 88);
    model.addSong("City of Stars", 95);
    model.addSong("Bohemian Rhapsody", 92);

    CsvView csv;
    csv.render(model, "原始数据（CSV 视图）");        // 视图 A 看源数据

    SortProxy proxy(model);                            // 排序发生在视图层
    proxy.sortBy(1, /*ascending=*/false);              // 按评分降序

    ConsoleView console;
    console.render(proxy, "按评分降序（控制台视图）");  // 视图 B 看同一份数据的另一种视角
    return 0;
}

程序输出：

=== 原始数据（CSV 视图） ===
歌名,评分
Yesterday,88
City of Stars,95
Bohemian Rhapsody,92

=== 按评分降序（控制台视图） ===
City of Stars (95)
Bohemian Rhapsody (92)
Yesterday (88)

请注意几个关键点：两个视图共享同一个 SongModel 实例；排序只改动了 order_ 这张映射表，源数据在内存里的顺序从未变化；新增一种视图（比如 JSON 视图）完全不需要碰 Model。把这三个事实平移到 Qt，就是 QTableView + QSortFilterProxyModel + QAbstractItemModel 的关系。

需求：一个音乐库窗口，三列（歌名 / 歌手 / 评分），评分用★星形绘制并能双击用微调框编辑，顶部搜索框实时筛选，评分列按数值降序排序。完整工程四个文件 + CMake。

songmodel.h —— Model 声明

#pragma once

#include <QAbstractTableModel>
#include <QString>
#include <QVector>

// 一条业务数据：与任何 UI 类型无关，可以被测试代码直接构造
struct Song {
    QString title;
    QString artist;
    int     rating = 0;      // 0 ~ 5 星
};

// ------------------------------------------------------------------
// SongModel：只做两件事 —— 回答视图的提问、在数据变化时通知视图
// ------------------------------------------------------------------
class SongModel : public QAbstractTableModel
{
    Q_OBJECT                 // 必须：需要 moc 生成元对象，信号槽才能工作

public:
    enum Column { TitleColumn = 0, ArtistColumn, RatingColumn, ColumnCount };
    enum Role   { RatingRole = Qt::UserRole + 1 };    // 自定义角色

    static constexpr int MinRating = 0;
    static constexpr int MaxRating = 5;

    explicit SongModel(QObject *parent = nullptr) : QAbstractTableModel(parent) {}

    // ---- 视图会问的三个基本问题 ----
    int rowCount(const QModelIndex &parent = QModelIndex()) const override
    { return parent.isValid() ? 0 : m_songs.size(); }

    int columnCount(const QModelIndex &parent = QModelIndex()) const override
    { return parent.isValid() ? 0 : int(ColumnCount); }

    QVariant data(const QModelIndex &index, int role) const override;
    QVariant headerData(int section, Qt::Orientation orientation, int role) const override;

    // ---- 写回路径 ----
    bool setData(const QModelIndex &index, const QVariant &value,
                 int role = Qt::EditRole) override;
    Qt::ItemFlags flags(const QModelIndex &index) const override;

    // ---- 结构变更：必须用 begin/end 包起来，否则视图索引会失效 ----
    void addSong(const Song &song);
    void removeSong(int row);

private:
    QVector<Song> m_songs;   // 私有：外部（包括视图）无法直接触碰
};

songmodel.cpp —— Model 实现

#include "songmodel.h"

#include <algorithm>    // std::clamp

QVariant SongModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid() || index.row() >= m_songs.size())
        return {};

    const Song &song = m_songs.at(index.row());

    // 核心思想落点：同一份数据，按"角色"回答不同的表现形态
    switch (role) {
    case Qt::DisplayRole:        // 显示用
    case Qt::EditRole:           // 编辑用（原始类型）
        switch (index.column()) {
        case TitleColumn:  return song.title;
        case ArtistColumn: return song.artist;
        case RatingColumn: return song.rating;      // 返回 int，不是 QString！
        default: break;
        }
        break;

    case Qt::TextAlignmentRole:
        return (index.column() == RatingColumn)
                   ? QVariant(int(Qt::AlignCenter))
                   : QVariant(int(Qt::AlignLeft | Qt::AlignVCenter));

    case Qt::ToolTipRole:
        return QStringLiteral("%1 — %2（%3 星）")
            .arg(song.title, song.artist).arg(song.rating);

    case RatingRole:             // 自定义角色：喂给委托画星星
        return song.rating;

    default:
        break;
    }
    return {};
}

QVariant SongModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role != Qt::DisplayRole || orientation != Qt::Horizontal)
        return {};
    switch (section) {
    case TitleColumn:  return QStringLiteral("歌名");
    case ArtistColumn: return QStringLiteral("歌手");
    case RatingColumn: return QStringLiteral("评分");
    default:           return {};
    }
}

bool SongModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if (!index.isValid() || role != Qt::EditRole || index.row() >= m_songs.size())
        return false;

    Song &song = m_songs[index.row()];
    switch (index.column()) {
    case TitleColumn:  song.title  = value.toString(); break;
    case ArtistColumn: song.artist = value.toString(); break;
    case RatingColumn: {
        bool ok = false;
        const int r = value.toInt(&ok);
        if (!ok)
            return false;
        // 业务规则集中在这一处，可被单元测试直接覆盖
        song.rating = std::clamp(r, int(MinRating), int(MaxRating));
        break;
    }
    default:
        return false;
    }

    // 内容变化（不是结构变化）→ 发 dataChanged，视图只重绘这一格
    emit dataChanged(index, index,
                     { Qt::DisplayRole, Qt::EditRole, Qt::ToolTipRole, RatingRole });
    return true;
}

Qt::ItemFlags SongModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
        return Qt::NoItemFlags;
    return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
}

void SongModel::addSong(const Song &song)
{
    const int row = m_songs.size();
    beginInsertRows(QModelIndex(), row, row);   // ① 通知：我要开始插了
    m_songs.append(song);                       // ② 真正改内部数据
    endInsertRows();                            // ③ 通知：插完了，视图重建索引
}

void SongModel::removeSong(int row)
{
    if (row < 0 || row >= m_songs.size())
        return;
    beginRemoveRows(QModelIndex(), row, row);
    m_songs.remove(row);
    endRemoveRows();
}

songdelegate.h / songdelegate.cpp —— 委托：把评分画成星星，并用微调框编辑

// ---------------- songdelegate.h ----------------
#pragma once
#include <QStyledItemDelegate>

class SongDelegate : public QStyledItemDelegate
{
    Q_OBJECT
public:
    using QStyledItemDelegate::QStyledItemDelegate;   // 继承构造函数

    void paint(QPainter *painter, const QStyleOptionViewItem &option,
               const QModelIndex &index) const override;
    QSize sizeHint(const QStyleOptionViewItem &option,
                   const QModelIndex &index) const override;
    QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option,
                          const QModelIndex &index) const override;
    void setEditorData(QWidget *editor, const QModelIndex &index) const override;
    void setModelData(QWidget *editor, QAbstractItemModel *model,
                      const QModelIndex &index) const override;
};

// ---------------- songdelegate.cpp ----------------
#include "songdelegate.h"
#include "songmodel.h"

#include <QApplication>
#include <QPainter>
#include <QSpinBox>
#include <QStyle>

void SongDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,
                         const QModelIndex &index) const
{
    // 只有评分列走自定义绘制，其它列老老实实交回基类
    if (index.column() != SongModel::RatingColumn) {
        QStyledItemDelegate::paint(painter, option, index);
        return;
    }

    QStyleOptionViewItem opt = option;
    initStyleOption(&opt, index);     // 先让基类把选中背景、分隔线等标准样式准备好
    opt.text.clear();                  // 文本由我们自己画，清掉防止重复渲染
    QApplication::style()->drawControl(QStyle::CE_ItemViewItem, &opt, painter);

    const int rating = index.data(SongModel::RatingRole).toInt();
    const int star   = qBound(12, opt.rect.height() - 6, 22);

    painter->save();
    painter->setRenderHint(QPainter::Antialiasing, true);
    QFont f = painter->font();
    f.setPointSizeF(star * 0.55);
    painter->setFont(f);

    for (int i = 0; i < SongModel::MaxRating; ++i) {
        const QRect cell(opt.rect.left() + 4 + i * star, opt.rect.top() + 3, star, star);
        painter->setPen(i < rating ? QColor(0xE8, 0x8A, 0x1E)     // 实星：暖橙
                                    : QColor(0xCC, 0xCC, 0xCC));  // 空星：浅灰
        painter->drawText(cell, Qt::AlignCenter, QStringLiteral("★"));
    }
    painter->restore();
}

QSize SongDelegate::sizeHint(const QStyleOptionViewItem &option,
                             const QModelIndex &index) const
{
    QSize s = QStyledItemDelegate::sizeHint(option, index);
    if (index.column() == SongModel::RatingColumn)
        s = s.expandedTo(QSize(SongModel::MaxRating * 20 + 10, 28));
    return s;
}

QWidget *SongDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option,
                                    const QModelIndex &index) const
{
    if (index.column() != SongModel::RatingColumn)
        return QStyledItemDelegate::createEditor(parent, option, index);

    auto *spin = new QSpinBox(parent);                 // 编辑器属于视图，不归模型管
    spin->setRange(SongModel::MinRating, SongModel::MaxRating);
    spin->setSuffix(QStringLiteral(" 星"));
    return spin;
}

void SongDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
{
    if (auto *spin = qobject_cast<QSpinBox *>(editor)) {
        spin->setValue(index.data(SongModel::RatingRole).toInt());
        return;
    }
    QStyledItemDelegate::setEditorData(editor, index);
}

void SongDelegate::setModelData(QWidget *editor, QAbstractItemModel *model,
                                const QModelIndex &index) const
{
    if (auto *spin = qobject_cast<QSpinBox *>(editor)) {
        spin->interpretText();                          // 保证手输未回车的内容也算数
        model->setData(index, spin->value(), Qt::EditRole);   // 唯一写回入口
        return;
    }
    QStyledItemDelegate::setModelData(editor, model, index);
}

main.cpp —— 组装：Model → Proxy → View → Delegate

#include "songdelegate.h"
#include "songmodel.h"

#include <QApplication>
#include <QHeaderView>
#include <QLineEdit>
#include <QSortFilterProxyModel>
#include <QTableView>
#include <QVBoxLayout>
#include <QWidget>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    // ① 一份数据（唯一真相），与 UI 完全解耦
    SongModel model;
    model.addSong({QStringLiteral("City of Stars"),     QStringLiteral("Ryan Gosling"), 5});
    model.addSong({QStringLiteral("Yesterday"),         QStringLiteral("The Beatles"),  4});
    model.addSong({QStringLiteral("Bohemian Rhapsody"), QStringLiteral("Queen"),        5});
    model.addSong({QStringLiteral("Imagine"),           QStringLiteral("John Lennon"),  3});

    // ② 代理模型：筛选 + 排序，源数据一个字节都不动
    QSortFilterProxyModel proxy;
    proxy.setSourceModel(&model);
    proxy.setFilterCaseSensitivity(Qt::CaseInsensitive);
    proxy.setFilterKeyColumn(-1);                   // -1 = 所有列都参与匹配
    proxy.setSortRole(SongModel::RatingRole);       // 关键：按数值角色排序而非字符串
    proxy.sort(SongModel::RatingColumn, Qt::DescendingOrder);

    // ③ 视图：只管画和收事件
    QTableView table;
    table.setModel(&proxy);
    table.setItemDelegateForColumn(SongModel::RatingColumn, new SongDelegate(&table));
    table.setSelectionBehavior(QAbstractItemView::SelectRows);
    table.setEditTriggers(QAbstractItemView::DoubleClicked
                          | QAbstractItemView::SelectedClicked);
    table.horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    table.verticalHeader()->setVisible(false);
    table.setAlternatingRowColors(true);

    // ④ 搜索框 → 直接改代理模型的过滤条件，表格自动刷新
    QLineEdit search;
    search.setPlaceholderText(QStringLiteral("搜索歌名或歌手…"));
    QObject::connect(&search, &QLineEdit::textChanged,
                     &proxy, &QSortFilterProxyModel::setFilterFixedString);

    QWidget window;
    auto *layout = new QVBoxLayout(&window);
    layout->addWidget(&search);
    layout->addWidget(&table);
    window.resize(680, 420);
    window.setWindowTitle(QStringLiteral("我的音乐库 — Model/View 演示"));
    window.show();

    return app.exec();
}

CMakeLists.txt（Qt6 + C++17）

cmake_minimum_required(VERSION 3.16)
project(SongLibrary LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_AUTOMOC ON)                 # Q_OBJECT 需要 moc 预处理

find_package(Qt6 REQUIRED COMPONENTS Widgets)

add_executable(songlibrary
    main.cpp
    songmodel.cpp
    songdelegate.cpp
)

target_link_libraries(songlibrary PRIVATE Qt6::Widgets)

构建与运行：

cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j
./build/songlibrary

整条链路的关键特征：没有任何"手动刷新界面"的调用（没有 update()、没有重新 setItem、没有遍历表格重填）。这就是"数据驱动界面"和"命令式改界面"的根本差别。

解耦点一：数据不知道视图存在。SongModel 只 #include <QAbstractTableModel>，它的头文件里找不到 QWidget、QTableView、QPainter 的任何痕迹。这意味着模型可以在没有图形界面的环境里被构造、被断言、被序列化。

解耦点二：视图不缓存数据。视图只在需要绘制时调用 data()，因此"屏幕上有几行"与"内存里有几行数据"完全无关。这就是 Qt 表格能轻松展示百万行的原因——一万行还是十万行，视图只为可见的约 30 行取数据。

解耦点三：写回只有一条路径。所有数据修改都必须经过 setData()（或 begin/end 包裹的结构操作）。业务规则（评分 0~5、必填校验、变更日志）可以集中在这一个函数里，而不是散落在十几个事件处理函数中。

① if-else / switch 膨胀。用 widget 直接存数据时，"评分列怎么显示"这件事会同时出现在四个地方：数据装载循环里（决定塞什么文本）、排序比较逻辑里（把字符串转回数字）、颜色/图标设置里（自定义 Qt::UserRole）、导出函数里（再解析一次文本）。每新增一种呈现形态（改成进度条、改成颜色条、加上"未评分"灰色态），四处都要改，漏一处就是不一致 bug。

② 类膨胀。同一份音乐数据要展示成"表格 + 树（按歌手分组）+ 下拉选择"三种形态。在无模式方案下，你需要三套装载代码、三套排序代码、三套导出代码；在 Model/View 下是：一个 Model，一个代理，三个视图各三行代码。

③ 耦合导致的"改不动"。业务同事要求"评分超过 4 星的歌名加粗显示"。如果数据在 widget 里，你只能在装载时判断一次——用户之后编辑评分，加粗不会更新，除非在编辑回调里再写一遍刷新逻辑。QStyledItemDelegate 的方案里，paint() 每次重绘都重新读数据，天然正确。

④ 隐性性能与正确性 bug。字符串排序（"9" > "100"）是经典正确性 bug；QTableWidget 每格一个 QTableWidgetItem + 拖拽/编辑状态，10 万行时内存和构建时间都难以接受；CSV 导出遍历 item(r, c) 遇到未填充的空指针会直接崩溃。这些都不是"写得不够仔细"，而是架构选错导致的必然结果。

✅ 适合使用的场景：

1. 表格 / 列表 / 树类数据展示，尤其是数据会被增删改的（日志查看器、任务管理器、文件浏览器、属性编辑器、调试面板）。
2. 同一份数据需要多个视图：表格 + 图表 + CSV 导出 + 状态栏统计，或者同时展示在桌面窗口和 QML 界面里。
3. 数据量较大或动态增删：需要"只为可见行取数据"的懒加载与增量刷新能力（千万级日志、内存快照分析）。
4. 需要对同一数据做不同排序/筛选/分组：典型做法是源 Model 只读，前面串一到两层 QSortFilterProxyModel，每种视角一个视图。
5. 需要把 C++ 数据暴露给 QML：QAbstractListModel + 重写 roleNames() 是 QML ListView/Repeater/TableView 的标准数据后端，比 QVariantList 属性高效得多。
6. 业务逻辑需要被单元测试：把规则放进 Model，测试不再依赖 GUI。

❌ 不适合使用的场景：

1. 一次性输出：只是想打印几行文本或显示一段说明，用 QLabel/QTextEdit 就够了。
2. 纯表单界面：一堆 QLineEdit + QComboBox 的配置对话框，用 QFormLayout 加几个成员变量比写 Model 直白得多。
3. 交互高度异构的"行"：每一行的操作按钮、布局、行为都完全不同（本质不是一个同质集合），那应该是自定义 widget 的场景，硬套 Model 只会把 data() 写成类型分派地狱。
4. 静态小数据集：一个 5 个选项、永不变化的 QComboBox，addItem 五次最快。

Qt 是把这个模式用到"自成一套子系统"的程度，下面这些全都是同一个协议的实例：

代码特征信号（看到这些就知道是模型-视图）：

1. 出现 QAbstractTableModel / QAbstractListModel 子类，且重写了 rowCount / columnCount / data(index, role) 三件套。
2. view->setModel(model)；而数据变化处出现 beginInsertRows/endInsertRows 或 emit dataChanged(...)。
3. data() 里出现 switch (role) —— 说明"同一份数据多种表现形态"这一核心思想落地了。
4. setItemDelegateForColumn(...) + 一个 QStyledItemDelegate 子类里同时存在 paint 与 createEditor。
5. 视图被包在 QSortFilterProxyModel 后面，且显式设置了 setSortRole / setFilterKeyColumn —— 这是"数据不动、视角可变"的标志。