C++03 用模板元編程替換預處理器指令

Question

我有一個嵌入式 C++03 代碼庫，需要支持不同供應商的小工具，但一次只能支持一個。 幾個小工具之間的大部分功能重疊，但也有一些獨占，而這些獨占功能正在產生我需要解決的問題。

下面是一個使用預處理器條件的笨拙代碼示例：

#define HW_TYPE1    0
#define HW_TYPE2    1

#define HW_TYPE HW_TYPE1

struct  GadgetBase  {
    void    FncA();
    // Many common methods and functions
    void    FncZ();
};
#if HW_TYPE==HW_TYPE2
struct  Gadget  :   public  GadgetBase  {
    bool    Bar()       {return(true);}
};
#else
struct  Gadget  :   public  GadgetBase  {
    bool    Foo()       {return(false);}
};
#endif

Gadget  A;

#if HW_TYPE==HW_TYPE2
bool    Test()  {return(A.Bar());}
#else
bool    Test()  {return(A.Foo());}

這是我在沒有預處理器指令的情況下將上述代碼轉換為 C++ 模板的嘗試。 由於我的特定平台上Test()的定義中的錯誤，以下代碼無法編譯，因為Foo()或Bar()未定義取決於Type的值。

enum    TypeE   {
    eType1,
    eType2
};

const TypeE Type= eType1; // Set Global Type

// Common functions for both Gadgets
struct  GadgetBase  {
    void    FncA();
    // Many common methods and functions
    void    FncZ();
};

// Unique functions for each gadget
template<TypeE  E=  eType1>
struct  Gadget  :   public  GadgetBase          {
    bool    Foo()       {return(false);}
};
template<>
struct  Gadget<eType2>  :   public  GadgetBase  {
    bool    Bar()       {return(true);}
};

Gadget<Type>    A;
template<TypeE  E=  eType1>
bool    Test()  {return(A.Foo());}
template<>
bool    Test()  {return(A.Bar());}

我想使用模板來做到這一點，以在添加新類型或附加功能時減少代碼更改的數量。 目前有五種類型，預計很快還會再增加兩種。 預處理器實現代碼很臭，我想在它變得笨拙之前清理它。

小工具代碼只占總代碼庫的一小部分，因此按小工具拆分整個項目可能也不理想。

即使每個項目只會使用一種類型，但未使用的類型仍然必須編譯，我如何最好地使用 C++03 進行設計（無 constexpr、const if 等）？ 我完全錯誤地接近這個嗎？ 我願意進行徹底的檢修。

編輯： Tomek 下面的解決方案讓我想知道它是否違反了 LSP。 實際上，另一種看待這個問題的方法是讓Test()成為需要實現的接口的一部分。 所以，這個例子可以重新考慮如下：

struct  GadgetI    {
    virtual bool Test()=0;
};
template<TypeE  E=  eType1>
struct  Gadget  :   public  GadgetBase, public GadgetI  {
    bool    Foo()       {return(false);}
    bool    Test()      {return Foo();}
};
template<>
struct  Gadget<eType2>  :   public  GadgetBase, public GadgetI  {
    bool    Bar()       {return(true);}
    bool    Test()      {return Bar();}
};
template<>
struct  Gadget<eType3>  :   public  GadgetBase, public GadgetI  {
    bool    Test()      {} // Violation of LSP?
};

或與編輯后的示例類似：

template<typename T>
bool Test(T& o)              {}  // Violation?
template<>
bool Test(Gadget<eType1> &o) {return(o.Foo());}
template<>
bool Test(Gadget<eType2> &o) {return(o.Bar());}

Test(A);

我可能想多了，我只是不想現在糟糕的設計以后再咬我。

Answer 1

我同意代碼看起來很復雜，我和你在一起。 但我相信你走錯了方向。 模板看起來很酷，但在這種情況下它們不是正確的工具。 使用模板，您將始終編譯所有選項，即使它們沒有被使用。

你想要相反的。 您一次只想編譯一個源代碼。 兩全其美的正確方法是將每個實現分隔在不同的文件中，然后使用外部方法選擇要包含/編譯的文件。

構建系統通常有很多用於這方面的工具。 例如，對於原生編譯，我們可以依靠 CMAKE 自己的CMAKE_SYSTEM_PROCESSOR來識別哪個是當前處理器。

如果要交叉編譯，則需要指定要編譯到的平台。

請記住，我有一個軟件需要在 Redhat、CentOS、Ubuntu、Suse 和 Windows/Mingw 等許多操作系統中編譯。 我有一個 bash 腳本文件，用於檢查環境並加載特定於該操作系統的工具鏈 cmake 文件。

你的情況似乎更簡單。 您可以只指出您想使用哪個平台，並指示構建系統只編譯特定於該平台的文件。

Answer 2

你到了那里:)。

重寫您的Test function 使其不依賴於全局小工具 object 而是將一個作為模板參數：

template<class T>
bool Test(T &o, std::integral_constant<bool (T::*)(), &T::Foo> * = 0)
{
  return(o.Foo());
}

template<class T>
bool Test(T &o, std::integral_constant<bool (T::*)(), &T::Bar> * = 0)
{
  return(o.Bar());
}

並將其稱為：

Test(A);

這依賴於 SFINAE（替代失敗不是錯誤）習語。 根據定義，編譯器將T的類型推斷為Gadget 。 現在，根據Foo和Bar function 的可用性，它將選擇其中一個重載。

請注意，如果Foo和Bar都在Gadget中定義，則此代碼將中斷，因為這兩個重載將匹配。

如果您不能在Gadget class 中包裝對 Foo 和 Bar 的調用，這會帶來一個問題：

template<TypeE  E=  eType1>
struct  Gadget  :   public  GadgetBase          {
    bool    Foo()       {return(false);}
    bool    Test()      {return Foo();}
};
template<>
struct  Gadget<eType2>  :   public  GadgetBase  {
    bool    Bar()       {return(true);}
    bool    Test()      {return Bar();}
};

並始終調用A.Test()代替？

編輯：

我可能過於復雜了。 以下重載可能是一種更簡單的方法：

bool Test(Gadget<eType1> &o)
{
  return(o.Foo());
}

bool Test(Gadget<eType2> &o)
{
  return(o.Bar());
}

Test(A);