Question

在我创建跨平台GUI框架的过程中，我遇到了以下问题：假设我有一个中心窗口＆＃34; class，在项目的一般，与平台无关的包含文件夹：

//include/window.hpp
class Window
{
    //Public interface
}

然后我有几个与平台相关的实现类，如下所示：

//src/{platform}/window.hpp
class WinWindow {...}; //Windows
class OSXWindow {...}; //OSX
class X11Window {...}; //Unix

最后，还有原始的Window类＆＃39; .cpp文件，我想要＆＃34;绑定＆＃34;一般类的实现类。纯粹在概念上，这是我想要做的：

//src/window.cpp
//Suppose we're on Windows

#include "include/window.hpp"
#include "src/win/window.hpp"
class Window : private WinWindow; //Redefine Window's inheritance

我知道这绝不是有效的C ++，这就是重点。我已经想到了解决这个问题的两种可能的方法，而且我都遇到了问题。

pImpl风格的实施

Make Window保存指向实现类的void指针，并将其分配给每个平台的不同窗口类。但是，每次我想执行平台相关操作时，我都必须向上转换指针，更不用说在任何地方都包含平台相关文件。

预处理程序指令

class Window :
#ifdef WIN32
private WinWindow
#else ifdef X11
private X11Window //etc.

然而，这听起来更像是一个黑客而不是问题的实际解决方案。

怎么办？我应该完全改变我的设计吗？我的任何可能的解决方案都能保留一点水吗？

Answer 1

使用typedef隐藏预处理器

您只需输入相应的窗口类型：

#ifdef WINDOWS
    typedef WinWindow WindowType;
#elif defined // etc

那么你的窗口类可能是：

class Window : private WindowType {
};

但这不是一个非常强大的解决方案。最好以面向对象的方式思考，但C ++中的OO编程需要运行时成本，除非你使用

奇怪地重复模板模式

您可以使用curiously repeating template pattern：

template<class WindowType>
class WindowBase {
public:
    void doSomething() {
        static_cast<WindowType *>(this)->doSomethingElse();
    }
};

然后你可以做

class WinWindow : public WindowBase<WinWindow> {
public:
    void doSomethingElse() {
        // code
    }
};

并使用它（假设C ++ 14支持）：

auto createWindow() {
#ifdef WINDOWS
    return WinWindow{};
#elif UNIX
    return X11Window{};
#endif
}

仅限C ++ 11：

auto createWindow()
    ->
#ifdef WINDOWS
    WinWindow
#elif defined UNIX
    X11Window
#endif
{
#ifdef WINDOWS
    return WinWindow{};
#elif defined UNIX
    return X11Window{};
#endif
}

我建议您在使用时使用auto，或将其与typedef结合使用：

auto window = createWindow();
window.doSomething();

面向对象的风格

您可以将Window类设为抽象类：

class Window {
protected:
    void doSomething();
public:
    virtual void doSomethingElse() = 0;
};

然后将依赖于平台的类定义为Window的子类。那么你所要做的就是在一个地方有预处理器指令：

std::unique_ptr<Window> createWindow() {
#ifdef WINDOWS
    return new WinWindow;
#elif defined OSX
    return new OSXWindow;
// etc
}

不幸的是，这会通过调用虚函数产生运行时成本。 CRTP版本在编译时而不是在运行时解析对“虚函数”的调用。

此外，这需要在堆上声明Window，而CRTP则不需要;这可能是一个问题，具体取决于用例，但总的来说，这并不重要。

最终，您必须在某处使用#ifdef，这样您就可以确定平台（或者您可以使用确定平台的库，但它也可能使用#ifdef），问题就是隐藏它的地方。

Answer 2

您可以使用CRTP模式实现静态多态：

class WindowBase {
     virtual void doSomething() = 0;
};

template<class WindowType>
class Window : public WindowBase {

    // Static cast when accessing the actual implementation:
    void doSomething() {
         static_cast<WindowType*>(this)->doSomethingElse();
    }
};

class X11WindowImpl : public Window<X11WindowImpl> {
    void doSomethingElse() {
       // blah ...
    }
};

class Win32WindowImpl : public Window<Win32WindowImpl> {
    void doSomethingElse() {
       // blah ...
    }
};

由于您的代码将被编译以满足特定目标，因此这应该是最精简的选项。

Answer 3

太棒了。您也可以编写一个类并使用#ifdef等定义它的内容，但您的解决方案不是黑客。如果您别无选择，只需编写多平台代码即可。

如何在编译时更改类继承的内容？

3 个答案:

使用typedef隐藏预处理器

奇怪地重复模板模式

面向对象的风格