Question

我为一个都继承了Gtkmm::Window的应用程序编写了几个窗口。在这一点上，我想使过程自动化。现在，以下结构引人注目：

class MyWindow : public Gtk::Window
{
public:
    MyWindow();
    virtual ~MyWindow();

    //...

private:
    void registerLayouts(); // Adds layouts to the window.
    void registerWidgets(); // Adds widgets to the layouts.

    //...
};

构造函数：

MyWindow::MyWindow()
{
    registerLayouts(); // Cannot be virtual: in constructor.
    registerWidgets(); // Cannot be virtual: in constructor.

    //...
}

因此，问题在于，每次必须对新窗口进行编程时，所有这些操作都必须手动完成（即复制/粘贴），因为在构造过程中会调用registerLayouts()和registerWidgets()，因此无法是virtual。

理想情况下，我将有一个可以继承的基类，它使我可以选择重写这两个方法，并照顾其余的方法：它将在适当的位置调用这两个方法。

问题是，我还没有找到这个合适的位置。我看过不同的信号处理程序，但是似乎没有。

您是否知道我该怎么做？

MFC的CDialog::OnInitDialog()执行与我所需的功能类似的操作。

Answer 1

您可以将作品委派给一个单独的班级：

class MyWindow : public Gtk::Window
{
//public:  *** EDIT ***
protected:
    template <typename LayoutManager>
    MyWindow(LayoutManager const& lm)
    {
        lm.registerLayouts(this);
        lm.registerWidgets(this);
    }
};

class SubWindow : public MyWindow
{
    class LM { /* ... */ };
public:
     SubWindow() : MyWindow(LM()) { }
};

（编辑：改进的模式对公众隐藏了子类的布局管理器...）

或者，将整个类作为模板~~（可能优于上面）~~：

template <typename LayoutManager>
class MyWindow : public Gtk::Window
{
public:
    MyWindow()
    {
        LayoutManager lm(*this);
        lm.registerLayouts();
        lm.registerWidgets();
    }
};

class SpecificLayoutManager { /* ... */ };
using SpecificWindow = MyWindow<SpecificLayoutManager>;

如果您还需要清理布局管理器（我自己不熟悉GTK ...）：

template <typename LayoutManager>
class MyWindow : public Gtk::Window
{
    LayoutManager lm;
public:
    MyWindow() : lm(*this)
    {
        lm.registerLayouts();
        lm.registerWidgets();
    }
    virtual ~MyWindow()
    {
        // still access to lm...
    }
};

重要的旁注：在所有变体中，我们还没有一个完全构造的派生类–在布局管理器中将后者强制转换为不合法（使用curiously recurring template pattern进行了实验，但是出于完全相同的原因而放弃了这个想法：也需要将其强制转换为base的构造函数中的派生代码。

根据评论进行编辑：有关如何管理子类的其他示例（使用上述第三个变体，其中的模板类为布局管理器成员； lm成员）现在需要为protected）：

class SubWindowLayoutManager
{
    template <typename>
    friend class MyWindow;
    friend class SubWindow;

    int someMember;

    void registerLayouts() { }
    void registerWidgets() { }

};
class SubWindow : public MyWindow<SubWindowLayoutManager>
{
    void doSomething()
    {
        lm.someMember = 77;
    }
};

另外一个完全没有模板的新变体：

class MyWindow : public Gtk::Window
{
protected:
    class LayoutManager
    {
    public:
         virtual void registerLayouts(MyWindow* parent) = 0;
         virtual void registerWidgets(MyWindow* parent) = 0;
    };

    std::unique_ptr<LayoutManager> lm;

    MyWindow(std::unique_ptr<LayoutManager> lm)
        : lm(std::move(lm))
    {
        this->lm->registerLayouts(this);
        this->lm->registerWidgets(this);
    }
};

class SubWindow : public MyWindow
{
    class LM : public LayoutManager
    {
    public:
        void registerLayouts(MyWindow* parent) override { }
        void registerWidgets(MyWindow* parent) override { }

        int someMember;
    };

    // convenience access function:
    inline LM& lm()
    {
        return *static_cast<LM*>(MyWindow::lm.get());
    }

public:
    SubWindow() : MyWindow(std::make_unique<LM>()) { }

    void doSomething()
    {
        //static_cast<LM*>(lm.get())->someMember = 77;
        lm().someMember = 77;
    }
};

通过基类自动进行窗口编程

1 个答案: