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!"); 
} 

main.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

本当に恐ろしいアイデアです。 「仮想機能のコストを避けたい」という大部分のアイデアと同様です。

セグメンテーションフォルト（具体的にスタックオーバーフロー）が発生する理由は、仮想関数を使用せずに静的リンクを使用しているからです。コンパイラは、がPlatformIndependantClass以外のものであることを知らないので、return mImplementation->GetPlatformName()を呼び出すと、何度も同じ関数を呼び出すことになります。

あなたが達成したことは、シャドウイングと呼ばれ、コンパイル時の関数解決を使用しています。コンパイラはから呼び出す変数の実際の型のGetPlatformName関数を呼び出します。これは実際の関数へのポインタを上書きする仮想テーブルがないためです。 mImplementationはPlatformIndependantClassなので、mImplementation->GetPlatformNameは常にPlatformIndependantClass::GetPlatformNameになります。

編集もちろん、WindowsとLinuxの両方のコピーを同時に作成する必要があるのは当然のことです。あなたは同時にそれらの両方を使用することはありません、そうですか？

なぜシステムごとに2つの異なるライブラリがあり、正しいものがメイクファイルからリンクされていないのでしょうか。あなたはすべての世界の中で最高のものを手に入れます！

Answer 3

代わりにプラットフォーム固有のインスタンスを構築するコンストラクタを使用して、私はインスタンスを作成するために、静的なファクトリメソッドを作成します。

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

あなたは再帰を避けるため、この方法を、あなたも必要ありません。あなたのmImplementationポインタ。

私はまた、プラットフォーム固有のクラスを避けるためにしようとするだろうが、それはまた別の話だ:)

Answer 4

コンストラクタが無限再帰を引き起こしているとは思わない。これはGetPlatformName（）関数です。仮想として設定されていないため、自分自身を呼び出すことができます。

2つの解決策：その機能を仮想化するか、継承を完全に廃止する。

いずれにせよ、別の関数を呼び出す関数のコストは、最初に仮想関数を使用するよりも高価になります。したがって、継承を維持し、プラットフォーム固有の関数を仮想化し、基本クラスの関数を経由せずに直接呼び出すといいでしょう。

Answer 5

ランタイムオーバーヘッドなしで多態的な動作をしたい場合は、curiously recurring template pattern (CRTP)を試すことができます。基本クラスはテンプレートであり、派生クラスはそれ自体を基底のテンプレートパラメータとして使用します。これには、クラスをテンプレートとして定義する必要があり、ヘッダー（.hpp）ファイルに完全に実装されるように制限します。

特定のケースでパターンを適用する方法がわかりません。

Answer 6

infinteループについては正しいですか。修正は実際にはあなたが考えるよりも簡単です。

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。

#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 

CPPここで定義されただけONEクラスがあります。ウィンドウズでは、コンパイルしてウィンドウズのものしか入っていません.Linuxでは、コンパイルしてLinuxのものしか含んでいません。 void*のことを「不透明ポインタ」または「pimplイディオム」と呼びます。http://en.wikipedia.org/wiki/Opaque_pointer