c++我怎样才能实现这个类结构？

Question

我正在绞尽脑汁试图找出如何编写跨平台类，同时避免虚拟函数的成本以及平台特定版本的类中的任何丑陋。这是我尝试过的。

PlatformIndependantClass.hpp

class PlatformIndependantClass {
    public:
        PlatformIndependantClass();
        std::string GetPlatformName();
    private:
        PlatformIndependantClass* mImplementation;

};

LinuxClass.hpp

#include "PlatformIndependantClass.hpp"
class LinuxClass : public PlatformIndependantClass{
    public:
        std::string GetPlatformName();
};

WindowsClass.hpp

#include "PlatformIndependantClass.hpp"
class WindowsClass : public PlatformIndependantClass {
    public:
        std::string GetPlatformName();
};

PlatformIndependantClass.cpp

#include "PlatformIndependantClass.hpp"
#include "LinuxClass.hpp"
#include "WindowsClass.hpp"
PlatformIndependantClass::PlatformIndependantClass() {
    #ifdef TARGET_LINUX
        mImplementation = new LinuxClass();
    #endif
    #ifdef TARGET_WINDOWS
        mImplementation = new WindowsClass();
    #endif
}
std::string PlatformIndependantClass::GetPlatformName() {
    return mImplementation->GetPlatformName();
}

LinuxClass.cpp

#include "LinuxClass.hpp"
std::string LinuxClass::GetPlatformName() {
    return std::string("This was compiled on linux!");
}

WindowsClass.cpp

#include "WindowsClass.hpp"
std::string WindowsClass::GetPlatformName() {
    return std::string("This was compiled on windows!");
}

ma​​in.cpp

#include <iostream>
#include "PlatformIndependantClass.hpp"

using namespace std;

int main()
{
    PlatformIndependantClass* cl = new PlatformIndependantClass();
    cout << "Hello world!" << endl;
    cout << "Operating system name is: " << cl->GetPlatformName() << endl;
    cout << "Bye!" << endl;
    return 0;
}

现在，编译正常，但出现分段错误。我相信这是因为平台特定类继承自 PlatformIndependantClass，它在构造时创建平台特定类的实例，所以我得到了无限递归。每次我尝试时，我都会感到非常困惑！

我怎样才能正确实现这样的设计？或者这只是一个可怕的想法。我一直在尝试找出如何编写跨平台类，但我只是得到了大量有关跨平台库的结果，任何帮助将不胜感激:)

Answer 1

我认为你想要完成的事情可以更容易完成......

Object.h：

#include <normal includes>

#if WINDOWS
#include <windows includes>
#endif

#if LINUX
#include <linux includes>
#endif

class Object
{
private:

#if WINDOWS
//Windows Specific Fields...
#endif

#if LINUX
//Linux Specific Fields...
#endif

public:
    //Function that performs platform specific functionality
    void DoPlatformSpecificStuff();

    //Nothing platform specific here
    void DoStuff();      
};

Object.cpp

#include "Object.h"

void Object::DoStuff() { ... }

ObjectWin32.cpp

#if WINDOWS

#include "Object.h"

void Object::DoPlatformSpecificStuff() 
{ 
    //Windows specific stuff... 
}

#endif

ObjectLinux.cpp

#if LINUX

#include "Object.h"

void Object::DoPlatformSpecificStuff() 
{ 
    //Linux specific stuff... 
}

#endif

等等。我认为这可以以更简单的方式完成您正在尝试的事情。此外，不需要虚拟函数。

Answer 2

从最后开始，是的，确实是一个可怕的想法，就像大多数以“我想避免虚拟函数的成本”开头的想法一样。

至于为什么会出现分段错误（特别是堆栈溢出），这是因为您没有使用虚拟函数，而是使用静态链接。编译器不知道 mImplementation 不是 PlatformIndependantClass，因此当您尝试调用 return mImplementation->GetPlatformName() 时，您一遍又一遍地调用同一个函数。

您所实现的称为“阴影”，您正在使用编译时函数解析。编译器将调用您从中调用的变量的实际类型的 GetPlatformName 函数，因为没有虚拟表可以覆盖指向实际函数的指针。由于mImplementation是PlatformIndependantClass，因此mImplementation->GetPlatformName将始终是PlatformIndependantClass::GetPlatformName。

编辑：当然，我会想到为什么需要同时创建引擎的 Windows 和 Linux 副本的问题。你永远不会同时使用它们，对吧？

那么为什么不只拥有两个不同的库，每个系统一个，然后从 makefile 链接正确的库。您将获得世界上最好的一切！

Answer 3

我不使用构造函数来构建特定于平台的实例，而是创建一个静态工厂方法来创建实例：

PlatformIndependantClass* PlatformIndependantClass::getPlatformIndependantClass() {
    #ifdef TARGET_LINUX
        return new LinuxClass();
    #endif
    #ifdef TARGET_WINDOWS
        return new WindowsClass();
    #endif
}

这样就可以避免递归，并且也不需要 mImplementation 指针。

我也会尝试避免特定于平台的类，但那是另一个故事了:)

Answer 4

当您希望在没有任何运行时开销的情况下实现多态行为时，可以尝试 奇怪的重复模板模式 (CRTP) 。基类是一个模板，派生类使用自身作为基类的模板参数。这需要将您的类定义为模板，这进一步限制了它们只能在头文件 (.hpp) 文件中完全实现。

我不确定如何在您的特定情况下应用该模式。

Answer 5

我不认为构造函数会导致无限递归。这是 GetPlatformName() 函数。因为它没有设置为virtual，所以它只能调用它自己。

两种解决方案：使该函数成为虚拟函数，或者完全取消继承。

无论哪种方式，一个函数仅调用另一个函数的成本都会比首先使用虚函数更昂贵。所以我想说保留继承，并虚拟化特定于平台的函数，并直接调用它们，而不需要通过基类函数。

Answer 6

您对无限循环的看法是正确的。修复实际上比您想象的要容易。

PlatformIndependantClass.hpp

#include //portable headers
struct PlatformDependantClass; //defined in Cpp file
class PlatformIndependantClass {
    public:
        PlatformIndependantClass();
        ~PlatformIndependantClass();
        std::string GetPlatformName();
    private:
        std::unique_ptr<PlatformDependantClass> mImplementation; //note, different type

};

LinuxClass.cpp

#ifdef __GNUC__ 
#include //linux headers
#include "PlatformIndependantClass.hpp"
struct PlatformDependantClass { //linux only stuff
     //stuff
};    

PlatformIndependantClass() {
    mImplementation.reset(new PlatformDependantClass );
}
~PlatformIndependantClass() {
}
std::string PlatformIndependantClass::GetPlatformName() {
    return std::string("This was compiled on linux!");
}
#endif //__GNUC__ 

WindowsClass.cpp

#ifdef _MSC_VER
#include //windows headers
#include "PlatformIndependantClass.hpp"
struct PlatformDependantClass {  //windows only stuff
     //stuff
};    

PlatformIndependantClass() {
    mImplementation.reset(new PlatformDependantClass );
}
~PlatformIndependantClass() {
}
std::string PlatformIndependantClass::GetPlatformName() {
    return std::string("This was compiled on Windows!");
}
#endif //_MSC_VER

这里只定义了一个类。在windows中，它只编译并包含windows的东西，在Linux中，它只编译并包含linux的东西。请注意，void* 事物被称为“不透明指针”或“pimpl idiom” http://en.wikipedia.org/wiki/Opaque_pointer