在这种特定的类层次结构设计中如何避免向下转换？

Question

我的任务是创建一种多平台 C++ GUI 库。它在不同平台上封装了不同的 GUI 框架。库本身提供了一个接口，用户可以通过该接口进行统一通信，而不管他使用的是什么平台。

我需要正确设计这个接口和与框架的底层通信。我试过的是：

1. Pimpl idiom - 最初选择此解决方案是因为它的优点 - 二进制兼容性、削减依赖关系树以增加构建时间...

class Base {
public:
    virtual void show();
    // other common methods
private:
    class impl;
    impl* pimpl_;
};

#ifdef Framework_A
class Base::impl : public FrameWorkABase{ /* underlying platform A code */ };
#elif Framework_B
class Base::impl : public FrameWorkBBase { /* underlying platform B code */ };
#endif

class Button : public Base {
public:
    void click();
private:
    class impl;
    impl* pimpl_;
};

#ifdef Framework_A
class Button::impl : public FrameWorkAButton{ /* underlying platform A code */ };
#elif Framework_B
class Button::impl : public FrameWorkBButton { /* underlying platform B code */ };
#endif

但是，据我了解，这种模式并不是为如此复杂的层次结构而设计的，在这种层次结构中，您可以轻松地扩展接口对象及其实现。例如。如果用户想从库 UserButton : Button 中继承按钮，他需要知道 pimpl idiom 模式的细节才能正确初始化实现。

1. 简单的实现指针 - 用户不需要知道库的底层设计 - 如果他想创建自定义控件，他只需将库控件子类化，其余的由库处理

#ifdef Framework_A
using implptr = FrameWorkABase;
#elif Framework_B
using implptr = FrameWorkBBase;
#endif

class Base {
public:
    void show();
protected:
    implptr* pimpl_;
};

class Button : public Base {
public:
    void click() {
#ifdef Framework_A
        pimpl_->clickA(); // not working, need to downcast
#elif Framework_B
        // works, but it's a sign of a bad design
        (static_cast<FrameWorkBButton>(pimpl_))->clickB();
#endif
    }
};

由于实现受到保护，Button 中将使用相同的 implptr 对象 - 这是可能的，因为 FrameWorkAButton 和 FrameWorkBButton 分别继承自 FrameWorkABBase 和 FrameWorkABase。这个解决方案的问题是每次我需要打电话时，例如在Button 类中类似于pimpl_->click()，我需要向下转换pimpl_，因为clickA() 方法不在FrameWorkABase 中，而是在FrameWorkAButton 中，所以它看起来像这样(static_cast<FrameWorkAButton>(pimpl_))->click()。过度沮丧是糟糕设计的标志。在这种情况下，访问者模式是不可接受的，因为Button 类和一大堆其他类支持的所有方法都需要一个访问方法。

有人可以告诉我，如何修改这些解决方案，或者提出其他解决方案，这在这种情况下会更有意义吗？提前致谢。

EDIT 基于 od @ruakh 的回答

所以 pimpl 解决方案如下所示：

class baseimpl; // forward declaration (can create this in some factory)
class Base {
public:
    Base(baseimpl* bi) : pimpl_ { bi } {}
    virtual void show();
    // other common methods
private:
    baseimpl* pimpl_;
};

#ifdef Framework_A
class baseimpl : public FrameWorkABase{ /* underlying platform A code */ };
#elif Framework_B
class baseimpl : public FrameWorkBBase { /* underlying platform B code */ };
#endif


class buttonimpl; // forward declaration (can create this in some factory)
class Button : public Base {
public:
    Button(buttonimpl* bi) : Base(bi), // this won't work
                             pimpl_ { bi } {}
    void click();
private:
    buttonimpl* pimpl_;
};

#ifdef Framework_A
class Button::impl : public FrameWorkAButton{ /* underlying platform A code */ };
#elif Framework_B
class Button::impl : public FrameWorkBButton { /* underlying platform B code */ };
#endif

问题在于在Button 的ctor 中调用Base(bi) 将不起作用，因为buttonimpl 不继承baseimpl，只是它的子类FrameWorkABase。

Answer 1

这个解决方案的问题是每次我需要打电话给例如在Button 类中类似于pimpl_->click()，我需要向下转换pimpl_，因为clickA() 方法不在FrameWorkABase 中，而是在FrameWorkAButton 中，所以它看起来像这样(static_cast<FrameWorkAButton>(pimpl_))->click()。

我能想到三种方法来解决这个问题：

1. 消除 Base::pimpl_ 以支持纯虚拟保护函数 Base::pimpl_()。让子类实现该函数以提供指向 Base::show（以及任何其他需要它的基类函数）的实现指针。
2. 将 Base::pimpl_ 设为私有而不是受保护，并为子类提供它们自己的适当类型的实现指针副本。 （由于子类负责调用基类构造函数，它们可以确保为它提供与计划使用相同的实现指针。）
3. 使 Base::show 成为纯虚函数（以及任何其他基类函数），并在子类中实现它。如果这导致代码重复，请创建一个子类可以使用的单独帮助函数。

我认为#3 是最好的方法，因为它避免了将你的类层次结构耦合到底层框架的类层次结构；但我怀疑你上面的cmets你会不同意。没关系。

---

例如如果用户想从库 UserButton : Button 中继承按钮，他需要知道 pimpl idiom 模式的细节才能正确初始化实现。

无论您采用何种方法，如果您不希望客户端代码必须设置实现指针（因为这意味着与底层框架交互），那么您将需要提供构造函数或工厂方法来执行此操作。由于您希望通过客户端代码支持继承，这意味着提供处理此问题的构造函数。所以我认为你写得太快了 Pimpl 成语。

---

关于您的编辑 - 而不是 Base::impl 和 Button::impl extend FrameworkABase 和 FrameworkAButton，您应该使 FrameworkAButton 成为 数据成员 Button::impl，并给 Base::impl 一个指向它的指针。 （或者你可以给 Button::impl 一个 std::unique_ptr 给 FrameworkAButton 而不是直接持有它；这样可以更容易地以明确定义的方式将指针传递给 Base::impl。）

例如：

#include <memory>

//////////////////// HEADER ////////////////////

class Base {
public:
    virtual ~Base() { }
protected:
    class impl;
    Base(std::unique_ptr<impl> &&);
private:
    std::unique_ptr<impl> const pImpl;
};

class Button : public Base {
public:
    Button(int);
    virtual ~Button() { }
    class impl;
private:
    std::unique_ptr<impl> pImpl;
    Button(std::unique_ptr<impl> &&);
};

/////////////////// FRAMEWORK //////////////////

class FrameworkABase {
public:
    virtual ~FrameworkABase() { }
};

class FrameworkAButton : public FrameworkABase {
public:
    FrameworkAButton(int) {
        // just a dummy constructor, to show how Button's constructor gets wired
        // up to this one
    }
};

///////////////////// IMPL /////////////////////

class Base::impl {
public:
    // non-owning pointer, because a subclass impl (e.g. Button::impl) holds an
    // owning pointer:
    FrameworkABase * const pFrameworkImpl;

    impl(FrameworkABase * const pFrameworkImpl)
        : pFrameworkImpl(pFrameworkImpl) { }
};

Base::Base(std::unique_ptr<Base::impl> && pImpl)
    : pImpl(std::move(pImpl)) { }

class Button::impl {
public:
    std::unique_ptr<FrameworkAButton> const pFrameworkImpl;

    impl(std::unique_ptr<FrameworkAButton> && pFrameworkImpl)
        : pFrameworkImpl(std::move(pFrameworkImpl)) { }
};

static std::unique_ptr<FrameworkAButton> makeFrameworkAButton(int const arg) {
    return std::make_unique<FrameworkAButton>(arg);
}

Button::Button(std::unique_ptr<Button::impl> && pImpl)
    : Base(std::make_unique<Base::impl>(pImpl->pFrameworkImpl.get())),
      pImpl(std::move(pImpl)) { }
Button::Button(int const arg)
    : Button(std::make_unique<Button::impl>(makeFrameworkAButton(arg))) { }

///////////////////// MAIN /////////////////////

int main() {
    Button myButton(3);
    return 0;
}