**Advanced Model-View-Controller (MVC) Architecture with Qt for a Personal Finance Manager** The Model-View-Controller (MVC) pattern is a widely used architectural design that separates an application into three main components: the model (data), view (user interface), and controller (interactions). In this example, we will create a Personal Finance Manager application using Qt and MVC architecture, showcasing how to effectively manage data and user interactions. **Components:** 1. **Model:** `TransactionModel` (stores transaction data) 2. **View:** `TransactionView` (displays transaction data) 3. **Controller:** `TransactionController` (manages interactions between model and view) **Design:** * Our `TransactionModel` will inherit from `QAbstractTableModel` to provide data access and modification functionality. * The `TransactionView` will be a `QTableView` that displays the transaction data. * The `TransactionController` will connect the model and view, handling user interactions (e.g., adding, removing, and updating transactions). **Source Code:** ```cpp // transactionmodel.h #ifndef TRANSACTIONMODEL_H #define TRANSACTIONMODEL_H #include <QAbstractTableModel> class TransactionModel : public QAbstractTableModel { Q_OBJECT public: enum Roles { DateRole = Qt::UserRole + 1, TypeRole, AmountRole }; explicit TransactionModel(QObject *parent = nullptr); ~TransactionModel() override; int rowCount(const QModelIndex &parent = QModelIndex()) const override; int columnCount(const QModelIndex &parent = QModelIndex()) const override; QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override; QHash<int, QByteArray> roleNames() const override; void addTransaction(const QDate &date, const QString &type, double amount); void removeTransaction(int row); void updateTransaction(int row, const QDate &date, const QString &type, double amount); private: QVector<QPair<QDate, QPair<QString, double>>> m_transactions; }; #endif // TRANSACTIONMODEL_H // transactionmodel.cpp #include "transactionmodel.h" TransactionModel::TransactionModel(QObject *parent) : QAbstractTableModel(parent) {} TransactionModel::~TransactionModel() {} int TransactionModel::rowCount(const QModelIndex &parent) const { Q_UNUSED(parent) return m_transactions.size(); } int TransactionModel::columnCount(const QModelIndex &parent) const { Q_UNUSED(parent) return 3; // Date, Type, Amount } QVariant TransactionModel::data(const QModelIndex &index, int role) const { if (!index.isValid()) return QVariant(); if (role == DateRole) return m_transactions.at(index.row()).first; else if (role == TypeRole) return m_transactions.at(index.row()).second.first; else if (role == AmountRole) return m_transactions.at(index.row()).second.second; return QVariant(); } QHash<int, QByteArray> TransactionModel::roleNames() const { QHash<int, QByteArray> roles; roles[DateRole] = "date"; roles[TypeRole] = "type"; roles[AmountRole] = "amount"; return roles; } void TransactionModel::addTransaction(const QDate &date, const QString &type, double amount) { beginInsertRows(QModelIndex(), m_transactions.size(), m_transactions.size()); m_transactions.append({date, {type, amount}}); endInsertRows(); } void TransactionModel::removeTransaction(int row) { beginRemoveRows(QModelIndex(), row, row); m_transactions.remove(row); endRemoveRows(); } void TransactionModel::updateTransaction(int row, const QDate &date, const QString &type, double amount) { m_transactions[row] = {date, {type, amount}}; emit dataChanged(index(row, 0), index(row, 2)); } // transactionview.h #ifndef TRANSACTIONVIEW_H #define TRANSACTIONVIEW_H #include <QTableView> #include <QObject> class TransactionModel; class TransactionView : public QTableView { Q_OBJECT public: explicit TransactionView(QWidget *parent = nullptr); void setModel(TransactionModel *model); private: TransactionModel *m_model; }; #endif // TRANSACTIONVIEW_H // transactionview.cpp #include "transactionview.h" #include "transactionmodel.h" TransactionView::TransactionView(QWidget *parent) : QTableView(parent) {} void TransactionView::setModel(TransactionModel *model) { m_model = model; QTableView::setModel(model); setModelColumn(0); setHorizontalHeaderLabels({"Date", "Type", "Amount"}); resizeColumnsToContents(); } // transactioncontroller.h #ifndef TRANSACTIONCONTROLLER_H #define TRANSACTIONCONTROLLER_H #include <QObject> class TransactionModel; class TransactionView; class TransactionController : public QObject { Q_OBJECT public: explicit TransactionController(QObject *parent = nullptr); void setModel(TransactionModel *model); void setView(TransactionView *view); public slots: void addTransaction(); void removeTransaction(); void updateTransaction(); private: TransactionModel *m_model; TransactionView *m_view; }; #endif // TRANSACTIONCONTROLLER_H // transactioncontroller.cpp #include "transactioncontroller.h" #include "transactionmodel.h" #include "transactionview.h" #include "dialog.h" TransactionController::TransactionController(QObject *parent) : QObject(parent) {} void TransactionController::setModel(TransactionModel *model) { m_model = model; } void TransactionController::setView(TransactionView *view) { m_view = view; } void TransactionController::addTransaction() { Dialog dialog; if (dialog.exec() == QDialog::Accepted) { m_model->addTransaction(dialog.getDate(), dialog.getType(), dialog.getAmount()); } } void TransactionController::removeTransaction() { QModelIndexList indexes = m_view->selectionModel()->selectedRows(); for (auto &index : indexes) { m_model->removeTransaction(index.row()); } } void TransactionController::updateTransaction() { QModelIndexList indexes = m_view->selectionModel()->selectedRows(); for (auto &index : indexes) { Dialog dialog; dialog.setDate(m_model->index(index.row(), 0).data(TransactionModel::DateRole).toDate()); dialog.setType(m_model->index(index.row(), 0).data(TransactionModel::TypeRole).toString()); dialog.setAmount(m_model->index(index.row(), 0).data(TransactionModel::AmountRole).toDouble()); if (dialog.exec() == QDialog::Accepted) { m_model->updateTransaction(index.row(), dialog.getDate(), dialog.getType(), dialog.getAmount()); } } } // dialog.h #ifndef DIALOG_H #define DIALOG_H #include <QDialog> #include "ui_dialog.h" class Dialog : public QDialog { Q_OBJECT public: explicit Dialog(QWidget *parent = nullptr); QDate getDate(); QString getType(); double getAmount(); void setDate(const QDate &date); void setType(const QString &type); void setAmount(double amount); private: Ui::Dialog ui; }; #endif // DIALOG_H ``` **Example Usage:** ```cpp // main.cpp #include "transactioncontroller.h" #include "transactionmodel.h" #include "transactionview.h" #include <QApplication> #include <QMainWindow> int main(int argc, char *argv[]) { QApplication app(argc, argv); QMainWindow mainwindow; TransactionModel model; TransactionView view; TransactionController controller; view.setModel(&model); controller.setModel(&model); controller.setView(&view); connect(&view, &TransactionView::doubleClicked, [&]() { controller.updateTransaction(); }); QPushButton *addButton = new QPushButton("Add Transaction"); connect(addButton, &QPushButton::clicked, [&]() { controller.addTransaction(); }); QPushButton *removeButton = new QPushButton("Remove Transaction"); connect(removeButton, &QPushButton::clicked, [&]() { controller.removeTransaction(); }); QVBoxLayout *layout = new QVBoxLayout; layout->addWidget(&view); QHBoxLayout *buttonLayout = new QHBoxLayout; buttonLayout->addWidget(addButton); buttonLayout->addWidget(removeButton); layout->addLayout(buttonLayout); QWidget *centralWidget = new QWidget; centralWidget->setLayout(layout); mainwindow.setCentralWidget(centralWidget); mainwindow.show(); return app.exec(); } ``` This example demonstrates an effective use of the MVC pattern in Qt, separating data storage and modification from user interactions and view updates. By utilizing this design pattern, we can create robust and maintainable applications with easy-to-update views and efficient data management.