MVP паттерн

#include <list>
 
class ViewBase;
class ModelBase;
class PresenterBase {
protected:
    std::list<ViewBase*> _views;
    ModelBase *_model;
    virtual ViewBase* CreateViewImpl() = 0;
public:
    PresenterBase(ModelBase *_model);
    ViewBase* CreateView();
    virtual void UpdateModel(ViewBase *sender) = 0;
};
 
class TextBoxPresenter: public PresenterBase {
protected:
    virtual ViewBase* CreateViewImpl() override;
public:
    using PresenterBase::PresenterBase;
    virtual void UpdateModel(ViewBase *sender) override;
};

#include "presenter.h"
#include "view.h"
#include "model.h"
#include <wx/log.h>
 
// Конструктор
PresenterBase::PresenterBase(ModelBase *model)
: _model(model) { }
 
// Создать представление
ViewBase* PresenterBase::CreateView() {
    ViewBase* view = CreateViewImpl();
    view->Subscribe(this);
    _views.push_front(view);
    return view;
}
 
// Создать конкретный экземпляр представления
ViewBase* TextBoxPresenter::CreateViewImpl() {
    return new TextBoxView();
}
 
// Алгоритм обновления модели 
void TextBoxPresenter::UpdateModel(ViewBase *sender) {
    if(_model->GetState()) {
        _model->SetState(false);
        std::string value = sender->GetValue();
        _model->SetValue(value);
        for(auto &view : _views) {
            if(view != sender) {
                view->SetValue(value);
            }
        }
        _model->SetState(true);
        wxLogMessage(wxString::Format("Send data to database\n\tID: %s,\n\tValue: %s", _model->GetID(), _model->GetValue()));
    }
 
}

#include "data_base_value.h"
#include <wx/panel.h>
#include <wx/textctrl.h>
#include <wx/window.h>
 
class PresenterBase;
class ViewBase: public DataBaseValue, public wxPanel {
protected:
    friend class PresenterBase;
    PresenterBase *_presenter;
    void Subscribe(PresenterBase *presenter);
public:
    virtual void Create(wxWindow *parent) = 0;
};
 
class TextBoxView: public ViewBase {
private:
    wxTextCtrl *_text;
public:
    virtual void Create(wxWindow *parent) override;
    virtual void SetValue(std::string const &value) override;
    virtual std::string GetValue() const override;
};

#include "view.h"
#include "presenter.h"
#include <wx/stattext.h>
#include <wx/sizer.h>
 
// Указать представителя
void ViewBase::Subscribe(PresenterBase *presenter) {
    _presenter = presenter;
}
 
// Создать представление
void TextBoxView::Create(wxWindow *parent) {
 
    // Создать панель
    wxPanel::Create(parent);
 
    // Создать элементы
    _text = new wxTextCtrl(this, wxID_ANY);
    wxStaticText *label = new wxStaticText(this, wxID_ANY, L"Текстовое поле:");
 
    // Создать макет для панели
    wxBoxSizer *this_sizer = new wxBoxSizer(wxHORIZONTAL);
    this_sizer->Add(label, 1);
    this_sizer->Add(_text, 1);
    SetSizerAndFit(this_sizer);
 
    // Создать событие
    _text->Bind(wxEVT_TEXT,
        [&](wxCommandEvent&) {
            if(_presenter) {
                _presenter->UpdateModel(this);
            }
        }
    );
}
 
// Указать значение (для работы с общим видом данных)
void TextBoxView::SetValue(std::string const &value) {
    _text->SetValue(wxString(value));
}
 
// Получить значение (для работы с общим видом данных)
std::string TextBoxView::GetValue() const {
    return _text->GetValue().ToStdString();
}

#include <string>
#include "data_base_value.h"
 
class ModelBase: public DataBaseValue {
private:
    std::string _id;
    bool _state;
public:
    ModelBase(std::string const &id);
    std::string GetID() const;
    void SetState(bool state);
    bool GetState() const;
};
 
class StringModel: public ModelBase {
private:
    std::string _value;
public:
    StringModel(std::string const &id, std::string const &value = std::string());
    virtual void SetValue(std::string const &value) override;
    virtual std::string GetValue() const override;
};

#include "model.h"
 
// Конструктор
ModelBase::ModelBase(std::string const &id)
: _id(id),
_state(true) { }
 
// Получить идентификатор
std::string ModelBase::GetID() const {
    return _id;
}
 
// Установить состояние
void ModelBase::SetState(bool state) {
    _state = state;
}
 
// Получить состояние
bool ModelBase::GetState() const {
    return _state;
}
 
// Конструктор строковой модели
StringModel::StringModel(std::string const &id, std::string const &value)
: ModelBase(id),
_value(value) { }
 
// Указать занчение (для работы с общим видом данных)
void StringModel::SetValue(std::string const &value) {
    _value = value;
}
 
// получить занчение (для представления)
std::string StringModel::GetValue() const {
    return _value;
}

#include <string>
 
class DataBaseValue {
public:
    virtual void SetValue(std::string const &value) = 0;
    virtual std::string GetValue() const = 0;
};

#include "app.h"
#include "view.h"
#include "model.h"
#include "presenter.h"
#include <wx/frame.h>
#include <wx/sizer.h>
 
class Frame: public wxFrame {
private:
    TextBoxPresenter *_text_box_preseter;
public:
    Frame()
        : wxFrame(nullptr, wxID_ANY, "Title") {
        // Создать представителя
        _text_box_preseter = new TextBoxPresenter(new StringModel("id_database_text_field"));
 
        // Создать представления
        ViewBase *f1 = _text_box_preseter->CreateView();
        ViewBase *f2 = _text_box_preseter->CreateView();
        ViewBase *f3 = _text_box_preseter->CreateView();
 
        // Добавить представления к форме
        f1->Create(this);
        f2->Create(this);
        f3->Create(this);
 
        // Создать макет формы
        wxBoxSizer *this_sizer = new wxBoxSizer(wxVERTICAL);
        this_sizer->Add(f1, 1);
        this_sizer->Add(f2, 1);
        this_sizer->Add(f3, 1);
        SetSizerAndFit(this_sizer);
    }
};
 
bool Application::OnInit() {
    Frame *f = new Frame();
    f->Show();
    return true;
}