真正允许在 C++ 中将实现与用户隔离的数据抽象

Question

我不敢问这个问题，因为它很简单。除非我找不到解决方案。

我最近尝试编写一个简单的程序，该程序在某种程度上忽略了引擎呈现其 UI 的方式。

理论上一切看起来都很棒，但实际上，理论并没有让我走得太远。

假设我的工具需要一个 IWindow 和 IContainer 来承载 ILabel 和 IButton。那是 4 个 UI 元素。去除其中的每一个都是一项微不足道的任务。我可以用 Qt、Gtk、motif 来创建这些元素中的每一个——你可以命名它。

我知道，为了实现（例如，QtWindow 和 QtContainer）工作，抽象（IWindow 和 IContainer）也必须工作：IWindow 需要能够接受IContainer 作为它的孩子：这需要任何一个

• 我可以将任何 UI 元素添加到容器中，或者
• 所有 UI 元素都继承自一个父元素

这是完美解决抽象问题的理论。实践（或实施）是另一回事。为了使实现与抽象一起工作-我认为我可以这样做

• 用暴露实现（或给出提示）的丑陋调用污染抽象——扼杀抽象的概念，或者
• 将抽象的转换添加到实现可以理解的内容 (dynamic_cast<>())。
• 将ISomething 实例的全局映射池添加到 UI 特定元素 (map<IElement*, QtElement*>())，这有点像强制转换，除了我自己完成。

所有这些看起来都很难看。我在这里看不到其他选择 - 这是数据抽象概念实际上失败的地方吗？投射是这里唯一的选择吗？

编辑

我花了一些时间试图提出最佳解决方案，这似乎是 C++ 无法简单完成的事情。不是没有强制转换，也不是使用模板。

我最终想出的解决方案（在处理了很多接口以及如何定义这些接口之后）如下所示：

1。需要有一个参数化的基本接口来定义调用

基本接口（我们称它为TContainerBase 用于容器，TElementBase 用于元素）指定预期由容器或元素实现的方法。那部分很简单。

定义需要遵循以下思路：

template <typename Parent>
class TElementBase : public Parent {
    virtual void DoSomething() = 0;
};

template <typename Parent>
class TContainerBase : public Parent {
    virtual void AddElement(TElementBase<Parent>* element) = 0;
};

2。需要有一个指定继承的模板。

这就是分离的第一阶段（引擎与用户界面）来的地方。此时，驱动渲染的后端类型无关紧要。这是有趣的部分：在我看来，唯一成功实现这一点的语言是 Java。模板必须看起来像这样：

一般：

template<typename Engine>
class TContainer : public TContainerBase<Parent> {
    void AddElement(TElementBase<Parent>* element) {
        // ...
    }
};

template<typename Engine>
class TElement : public TElementBase<Parent> {
    void DoSomething() {
        // ...
    }
};

3。 UI 需要能够仅接受 TContainers 或 TElements

也就是说，它必须忽略这些元素的来源。这是分离的第二阶段；毕竟它关心的是TElementBase 和TContainerBase 接口。在 Java 中，通过引入问号已解决。就我而言，我可以简单地在我的 UI 中使用：

TContainer<?> some_container;
TElement<?> some_element;
container.AddElement(&element);

vtable 中的虚函数调用没有问题，因为它们正是编译器所期望的。唯一的问题是确保模板参数在两种情况下都相同。假设后端是一个单一的库 - 这会很好。

上述三个步骤可以让我完全（并且安全地）编写代码而无需考虑后端，而后端几乎可以实现任何需要的东西。

我尝试了这种方法，它变得非常理智。唯一的限制是编译器。实例化类并在这里来回转换它们是违反直觉的，但不幸的是，这是必要的，主要是因为使用模板继承，您不能只提取基类本身，也就是说，您不能说任何一个：

class IContainerBase {};

template <typename Parent>
class TContainerBase : public (IContainerBase : public Parent) {}

也没有

class IContainerBase {};
template <typename Parent>
typedef class IContainerBase : public Parent TContainerBase;

（请注意，在上述所有解决方案中，感觉完全自然而理智地依赖 TElementBase 和 TContainerBase - 如果您将 TElementBase<Foo> 转换为TElementBase<Bar> - 所以这只是语言限制）。

无论如何，这些最终语句（类 A 的 typedef 继承自 B 和类 X 的基类 A 继承自 B）在 C++ 中只是垃圾（并且会使语言变得比现在更难），因此唯一的出路是遵循提供的解决方案之一，我非常感谢。

感谢大家的帮助。

Answer 1

您在这里尝试使用面向对象。 OO 有一种实现通用代码的特殊方法：通过类型擦除。 IWindow 基类接口删除了确切的类型，在您的示例中为QtWindow。在 C++ 中，您可以通过 RTTI 取回一些已擦除的类型信息，即dynamic_cast。

但是，在 C++ 中，您也可以使用模板。不要实现IWindow和QtWindow，而是实现Window<Qt>。这允许您声明Container<Foo> 接受Window<Foo> 用于任何可能的Foo 窗口库。编译器会强制执行。

Answer 2

如果我正确理解您的问题，这就是 Abstract Factory Pattern 旨在解决的那种情况。

抽象工厂模式提供了一种封装一组具有共同主题的独立工厂的方法，而无需指定它们的具体类。在正常使用中，客户端软件创建抽象工厂的具体实现，然后使用工厂的通用接口来创建作为主题一部分的具体对象。客户不知道（或关心）它从这些内部工厂中的每一个获得哪些具体对象，因为它仅使用其产品的通用接口。这种模式将一组对象的实现细节与它们的一般用法分开，并依赖于对象组合，因为对象创建是在工厂接口中公开的方法中实现的。

Answer 3

创建一个能够抽象 Qt 和 Gtk 等库的包装器对我来说似乎不是一件容易的事。但是更一般地谈论您的设计问题，也许您可​​以使用模板来进行抽象接口和特定实现之间的映射。例如：

抽象界面IWidget.h

template<typename BackendT>
class IWidget
{
public:
    void doSomething()
    {
        backend.doSomething();
    }

private:
    BackendT backend;
};

Qt实现QtWidget.h：

class QtWidget
{
public:
    void doSomething()
    {
        // qt specifics here
        cout << "qt widget" << endl;
    }
};

Gtk 实现GtkWidget.h：

class GtkWidget
{
public:
    void doSomething()
    {
        // gtk specifics here
        cout << "gtk widget" << endl;
    }
};

Qt 后端QtBackend.h：

#include "QtWidget.h"
// include all the other gtk classes you implemented...
#include "IWidget.h"

typedef IWidget<QtWidget> Widget;
// map all the other classes...

Gtk 后端GtkBackend.h：

#include "GtkWidget.h"
// include all the other gtk classes you implemented...
#include "IWidget.h"

typedef IWidget<GtkWidget> Widget;
// map all the other classes...

应用：

// Choose the backend here:
#include "QtBackend.h"

int main()
{
    Widget* w = new Widget();
    w->doSomething();

    return 0;
}