c++ - C++ 和 QT 中的 MVC 和主题观察者模式

Question

免责声明:

正如第一个答案所指出的那样，在当前的示例案例中使用 MVC 是矫枉过正的。该问题的目的是通过一个简单的例子来理解基本概念，以便能够在修改更复杂数据(数组、对象)的更大程序中使用它们。

---

我正在尝试在 C++ 和 QT 中实现 MVC 模式，类似于这里的问题:

Other MVC Questions

该程序有 2 行编辑:

• mHexLineEdit
• mDecLineEdit

3个按钮

• mConvertToHexButton
• mConvertoDecButton
• mClearButton

并且只是修改字符串。

与另一个问题的不同之处在于，我正在尝试实现主题/观察者模式，以便在模型更改后更新 View 。

模型.h

#ifndef MODEL_H
#define MODEL_H

#include <QString>
#include <Subject>

class Model : virtual public Subject
{
public:
    Model();
    ~Model();
    void convertDecToHex(QString iDec);
    void convertHexToDec(QString iHex);
    void clear();

    QString getDecValue() {return mDecValue;}
    QString getHexValue() {return mHexValue;}
private:
    QString mDecValue;
    QString mHexValue;
};
#endif // MODEL_H

模型.cpp

#include "Model.h"

Model::Model():mDecValue(""),mHexValue(""){}
Model::~Model(){}

void Model::convertDecToHex(QString iDec)
{
    mHexValue = iDec + "Hex";

    notify("HexValue");
}

void Model::convertHexToDec(QString iHex)
{
    mDecValue = iHex + "Dec";

    notify("DecValue");
}

void Model::clear()
{
  mHexValue = "";
  mDecValue = "";

  notify("AllValues");
}

View.h

#ifndef VIEW_H
#define VIEW_H

#include <QtGui/QMainWindow>
#include "ui_View.h"
#include <Observer>

class Controller;
class Model;
class View : public QMainWindow, public Observer
{
    Q_OBJECT

public:
    View(QWidget *parent = 0, Qt::WFlags flags = 0);
    ~View();
    void setController(VController* iController);
    void setModel(VModel* iModel);
    QString getDecValue();
    QString getHexValue();
public slots:
    void ConvertToDecButtonClicked();
    void ConvertToHexButtonClicked();
    void ClearButtonClicked();
private:

    virtual void update(Subject* iChangedSubject, std::string iNotification);

    Ui::ViewClass ui;

    Controller*  mController;
    Model*        mModel;
};

#endif // VIEW_H

查看.cpp

#include "View.h"
#include "Model.h"
#include "Controller.h"
#include <QSignalMapper>

VWorld::VWorld(QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags)
{
    ui.setupUi(this);

    connect(ui.mConvertToHexButton,SIGNAL(clicked(bool)),this,SLOT(ConvertToHexButtonClicked()));
    connect(ui.mConvertToDecButton,SIGNAL(clicked(bool)),this,SLOT(ConvertToDecButtonClicked()));
    connect(ui.mClearButton,SIGNAL(clicked(bool)),this,SLOT(ClearButtonClicked()));
}

View::~View(){}

void View::setController(Controller* iController)
{
    mController = iController;

    //connect(ui.mConvertToHexButton,SIGNAL(clicked(bool)),this,SLOT(mController->OnConvertToHexButtonClicked(this)));
    //connect(ui.mConvertToDecButton,SIGNAL(clicked(bool)),this,SLOT(mController->OnConvertToDecButtonClicked(this)));
    //connect(ui.mClearButton,SIGNAL(clicked(bool)),this,SLOT(mController->OnClearButtonClicked(this)));
}

void View::setModel(Model* iModel)
{
    mModel = iModel;

    mModel->attach(this);
}

QString View::getDecValue()
{
    return ui.mDecLineEdit->text();
}

QString View::getHexValue()
{
    return ui.mHexLineEdit->text();
}

void View::ConvertToHexButtonClicked()
{
    mController->OnConvertToHexButtonClicked(this);
}

void View::ConvertToDecButtonClicked()
{
    mController->OnConvertToDecButtonClicked(this);
}

void VWorld::ClearButtonClicked() 
{
    mController->OnClearButtonClicked(this);
}

void View::update(Subject* iChangedSubject, std::string     iNotification)
{
    if(iNotification.compare("DecValue") == 0)
    {
        ui.mDecLineEdit->setText(mModel->getDecValue());
    }
    else if(iNotification.compare("HexValue") == 0)
    {
        ui.mHexLineEdit->setText(mModel->getHexValue());
    }
    else if(iNotification.compare("AllValues") == 0)
    {
        ui.mDecLineEdit->setText(mModel->getDecValue());
        ui.mHexLineEdit->setText(mModel->getHexValue());
    }
    else
    {
        //Unknown notification;
    }
}

Controller.h

#ifndef CONTROLLER_H
#define CONTROLLER_H

//Forward Declaration
class Model;
class View;

class Controller 
{
public:
    Controller(Model* iModel);
    virtual ~Controller();
    void OnConvertToDecButtonClicked(View* iView);
    void OnConvertToHexButtonClicked(View* iView);
    void OnClearButtonClicked(View* iView);
private:
    Model* mModel;
};
#endif // CONTROLLER_H

Controller.cpp

#include "Controller.h"
#include "Model.h"
#include "View.h"

Controller::Controller(Model* iModel):mModel(iModel){}

Controller::~Controller(){}

void Controller::OnConvertToDecButtonClicked(View* iView) 
{
  QString wHexValue = iView->getHexValue();

  mModel->convertHexToDec(wHexValue);
}

void Controller::OnConvertToHexButtonClicked(View* iView) 
{
  QString wDecValue = iView->getDecValue();

  mModel->convertDecToHex(wDecValue);
}

void Controller::OnClearButtonClicked(View* iView) 
{
  mModel->clear();
}

main.cpp

#include "View.h"
#include "Model.h"
#include "Controller.h"
#include <QtGui/QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Model wModel;
    View wView;
    Controller wCtrl(&wModel);
    wView.setController(&wCtrl);
    wView.setModel(&wModel);
    wView.show();
    return a.exec();
}

如果相关，我可以稍后发布主题/观察者文件。

除了一般性评论，有人可以回答这些问题吗:

1) 将按钮信号直接连接到 Controller 插槽会更好吗(就像在 View::setController 中注释掉的部分)？ Controller 需要知道调用了哪个 View，以便它可以使用来自 View 的正确信息，不是吗？这意味着:

a) Reimplement a QSignalMapper或

b) Upgrade to Qt5 and VS2012 in order to connect directly with lambdas (C++11) ;

2) 当模型调用更新时，了解更改内容的最佳方法是什么？它是通过所有可能性的切换/循环，预定义的映射...？

3) 另外，我应该通过更新函数传递必要的信息，还是让 View 在收到通知后检查 Model 的所需值？

在第二种情况下， View 需要访问模型数据...

---

编辑:

特别是在修改了很多数据的情况下。例如，有一个加载按钮，并且修改了整个对象/数组。通过信号/槽机制将拷贝传递给 View 将非常耗时。

来自ddriver的回答

Now, it would be a different matter if you have a traditional "list of items" model and your view is a list/tree/table, but your case is one of a single form.

---

4) View 是否需要引用模型？因为它只作用于 Controller ？ ( View ::设置模型())

如果不是，它如何将自己注册为模型的观察者？

Answer 1

您对一些微不足道的事情想得太多了。您也过度设计了。

是的，从 UI 中抽象逻辑总是一个好主意，但是对于您的特定示例，不需要额外的数据抽象层，主要是因为您没有不同的数据集，您只有两个实际上是逻辑的一部分并且不值得数据抽象层的值。

现在，如果您有一个传统的“项目列表”模型并且您的 View 是一个列表/树/表，但您的案例是一个单一的表单，那将是另一回事。

在您的情况下，正确的设计应该是一个 Converter 类，它包括您当前的模型数据、 Controller 和转换逻辑，以及一个 ConverterUI 类，它本质上是您的查看表格。您可以节省样板代码和组件互连。

话虽这么说，你可以自由地经历不必要的长度和矫枉过正。

1 - 你将修改数据从 View 发送到 Controller 连接，所以它总是来自适当的 View ， Controller 不关心它是哪个 View ，可能有多少个 View ，或者是否有一个查看所有。 QSignalMapper 是一个选项，但它相当有限——它只支持单个参数和几种参数类型。老实说，我自己更喜欢单线槽，它们更灵活，编写起来也不难，而且它们是可重用的代码，有时会派上用场。 Lambdas 是一个很酷的新功能，使用它们肯定会让你看起来更酷，但在你的特定情况下它们不会产生太大的不同，而且单独的 lambdas 不值得切换到 Qt5。话虽这么说，除了 lambda 之外，还有更多理由更新到 Qt5。

2 - 信号和槽，你知道你在编辑什么，所以你只更新那个

3 - 通过信号传递值更优雅，它不需要您的 Controller 保留对 View 的引用并管理它是哪个 View ，如 1 中所述

4 - 从 MVC 图中可以明显看出， View 具有对模型的引用，仅供阅读。因此，如果您想要一个“循规蹈矩”的 MVC，这就是您所需要的。

我对前面的例子进行了改进(有点，仍然未经测试)，现在有 Data 这只是一个常规结构，你肯定不希望它是一个 QObject 派生如果你要有很多这样的东西，因为 QObject 是巨大的内存开销，维护数据集的 Model，Controller 迭代底层的 Model 数据集并读写数据，View 绑定(bind)到 Controller ，App 将它们结合在一起一个模型和两个独立的 Controller 以及两个独立的 View 。功能有限 - 您可以转到下一个可用数据集条目、修改或删除，在此示例中没有添加或重新排序，您可以将这些作为练习来实现。更改将传播回模型，从而反射(reflect)在每个 Controller 和关联的 View 中。您可以将多个不同的 View 绑定(bind)到一个 Controller 。 Controller 的模型目前是固定的，但如果你想改变它，你必须经过一个类似于为 View 设置 Controller 的过程 - 即在连接到新 Controller 之前断开旧 Controller ，尽管如果你是删除旧的，它会自动断开连接。

struct Data {
    QString d1, d2;
};

class Model : public QObject {
    Q_OBJECT
    QVector<Data> dataSet;
  public:
    Model() {
      dataSet << Data{"John", "Doe"} << Data{"Jane", "Doe"} << Data{"Clark", "Kent"} << Data{"Rick", "Sanchez"};
    }
    int size() const { return dataSet.size(); }
  public slots:
    QString getd1(int i) const { return i > -1 && i < dataSet.size() ? dataSet[i].d1 : ""; }
    QString getd2(int i) const { return i > -1 && i < dataSet.size() ? dataSet[i].d2 : ""; }
    void setd1(int i, const QString & d) {
      if (i > -1 && i < dataSet.size()) {
        if (dataSet[i].d1 != d) {
          dataSet[i].d1 = d;
          emit d1Changed(i);
        }
      }
    }
    void setd2(int i, const QString & d) {
      if (i > -1 && i < dataSet.size()) {
        if (dataSet[i].d2 != d) {
          dataSet[i].d2 = d;
          emit d2Changed(i);
        }
      }
    }
    void remove(int i) {
      if (i > -1 && i < dataSet.size()) {
        removing(i);
        dataSet.remove(i);
        removed();
      }
    }
  signals:
    void removing(int);
    void removed();
    void d1Changed(int);
    void d2Changed(int);
};

class Controller : public QObject {
    Q_OBJECT
    Model * data;
    int index;
    bool shifting;
  public:
    Controller(Model * _m) : data(_m), index(-1), shifting(false) {
      connect(data, SIGNAL(d1Changed(int)), this, SLOT(ond1Changed(int)));
      connect(data, SIGNAL(d2Changed(int)), this, SLOT(ond2Changed(int)));
      connect(data, SIGNAL(removing(int)), this, SLOT(onRemoving(int)));
      connect(data, SIGNAL(removed()), this, SLOT(onRemoved()));
      if (data->size()){
        index = 0;
        dataChanged();
      }
    }
  public slots:
    QString getd1() const { return data->getd1(index); }
    QString getd2() const { return data->getd2(index); }
    void setd1(const QString & d) { data->setd1(index, d); }
    void setd2(const QString & d) { data->setd2(index, d); }
    void remove() { data->remove(index); }
  private slots:
    void onRemoving(int i) { if (i <= index) shifting = true; }
    void onRemoved() {
      if (shifting) {
        shifting = false;
        if ((index > 0) || (index && !data->size())) --index;
        dataChanged();
      }
    }
    void ond1Changed(int i) { if (i == index) d1Changed(); }
    void ond2Changed(int i) { if (i == index) d2Changed(); }
    void fetchNext() {
      if (data->size()) {
        index = (index + 1) % data->size();
        dataChanged();
      }
    }
  signals:
    void dataChanged();
    void d1Changed();
    void d2Changed();
};

class View : public QWidget {
    Q_OBJECT
    Controller * c;
    QLineEdit * l1, * l2;
    QPushButton * b1, * b2, * bnext, * bremove;
  public:
    View(Controller * _c) : c(nullptr) {
      QVBoxLayout * l = new QVBoxLayout;
      setLayout(l);
      l->addWidget(l1 = new QLineEdit(this));
      l->addWidget(b1 = new QPushButton("set", this));
      connect(b1, SIGNAL(clicked(bool)), this, SLOT(setd1()));
      l->addWidget(l2 = new QLineEdit(this));
      l->addWidget(b2 = new QPushButton("set", this));
      connect(b2, SIGNAL(clicked(bool)), this, SLOT(setd2()));
      l->addWidget(bnext = new QPushButton("next", this));
      l->addWidget(bremove = new QPushButton("remove", this));
      setController(_c);
    }
    void setController(Controller * _c) {
      if (_c != c) {
        if (c) {
          disconnect(c, SIGNAL(d1Changed()), this, SLOT(updateL1()));
          disconnect(c, SIGNAL(d2Changed()), this, SLOT(updateL2()));
          disconnect(c, SIGNAL(dataChanged()), this, SLOT(updateForm()));
          disconnect(bnext, SIGNAL(clicked(bool)), c, SLOT(fetchNext()));
          disconnect(bremove, SIGNAL(clicked(bool)), c, SLOT(remove()));
          c = nullptr;
        }
        c = _c;
        if (c) {
          connect(c, SIGNAL(d1Changed()), this, SLOT(updateL1()));
          connect(c, SIGNAL(d2Changed()), this, SLOT(updateL2()));
          connect(c, SIGNAL(dataChanged()), this, SLOT(updateForm()));
          connect(bnext, SIGNAL(clicked(bool)), c, SLOT(fetchNext()));
          connect(bremove, SIGNAL(clicked(bool)), c, SLOT(remove()));
        }
      }
      updateForm();
    }
  public slots:
    void updateL1() { l1->setText(c ? c->getd1() : ""); }
    void updateL2() { l2->setText(c ? c->getd2() : ""); }
    void updateForm() {
      updateL1();
      updateL2();
    }
    void setd1() { c->setd1(l1->text()); }
    void setd2() { c->setd2(l2->text()); }
};

class App : public QWidget {
    Q_OBJECT
    Model m;
    Controller c1, c2;
  public:
    App() : c1(&m), c2(&m) {
      QVBoxLayout * l = new QVBoxLayout;
      setLayout(l);          
      l->addWidget(new View(&c1));          
      l->addWidget(new View(&c2));
    }
};