使用模板參數的實現（如果可用），否則默認爲

Question

我想爲不同的Controller創建Frontend模板類。該Frontend應該使用Controller的實施方法（如果可用）（即功能的支持），以及一個默認的，否則，在

template <typename Controller> 
class Frontend 
{ 
    public: 
    something() 
    { 
     // use Controller::something() if possible 
     // else use default implementation 
    } 
}; 

• Frontend將使用類型特徵內部找出更多關於Controller,
• 不應要求Controller從任何提供默認實現的基類派生，因爲默認方法實現將需要Frontend的私有信息。

在Controller中將會有大約20種方法可能實施。我試圖創建一個提供有關提供實現信息（嵌套）性狀：

// (T: Controller class) 
T::supportsFeature<FeatureClass, ...>::type 

所以Controller::supportsFeature<>必須提供告知具體的實現。如果控制器支持功能，則::type爲std::true_type，否則爲std::false_type。爲此，我創建了一個默認結構來禁用任何功能，因此Controller類必須明確啓用它提供的任何功能。這似乎是從Controller攜帶信息到Frontend的一個舒適的方式，但它有兩個主要缺點：

1. 很難爲他人（誰最終將提供Controller）實施supportsFeature，因爲一個專業化嵌套traits類必須寫

2. 我不知道我應該怎麼evaulate要素的存在在Frontend::something()，因爲沒有參數取決於功能的存在 - 我不能提供過載是合理的表現（我不想超載std::true_type vs std::false_type，因爲這根本不會爲自己說話）。我可以簡單地使用if語句並依靠編譯器來刪除死代碼。我是不是該？

所以，總結一下：

• 如何執行有關從模板類參數模板類的方法是否存在信息？
• 基於這些信息，我該如何正確切換實現？

Answer 1

我用它來查看準確的簽名：

#include <cstdint> 

#define DEFINE_HAS_SIGNATURE(traitsName, funcName, signature)    \ 
    template <typename U>             \ 
    class traitsName              \ 
    {                  \ 
    private:                \ 
     template<typename T, T> struct helper;        \ 
     template<typename T>            \ 
     static std::uint8_t check(helper<signature, &funcName>*);   \ 
     template<typename T> static std::uint16_t check(...);    \ 
    public:                 \ 
     static                \ 
     constexpr bool value = sizeof(check<U>(0)) == sizeof(std::uint8_t); \ 
    } 

DEFINE_HAS_SIGNATURE(has_something, T::something, void (T::*)()); 

然後使用SFINAE（類似）：

template <typename Controller> 
class Frontend 
{ 
public: 
    void something() 
    { 
     somethingT<Controller>(); 
    } 

private: 
    template <typename T> 
    typename std::enable_if<has_something<T>::value>::type 
    somethingT() 
    { 
     controller.something(); 
    } 

    template <typename T> 
    typename std::enable_if<!has_something<T>::value>::type 
    somethingT() 
    { 
     // default implementation 
    } 
}; 

或標籤調度（類似）：

template <typename Controller> 
class Frontend 
{ 
public: 
    void something() 
    { 
     something(typename std::conditional<has_something<Controller>::value, 
      std::true_type, 
      std::false_type>::type()); 
    } 

private: 
    void something(std::true_type) { controller.something(); } 
    void something(std::false_type) { /* default implementation */ } 
}; 

Answer 2

經過一些嘗試/錯誤，這裏是我想要的一個可接受的解決方案。

使用SFINAE，當然，所有關於是否使用Controller的成員函數或默認函數的扣除都是在編譯時完成的。

控制器類型的實現者唯一需要的是在控制器中將類型定義爲typedef Controller WithSomething;。與你提到的特徵相比，這並不難。

---

首先聲明Frontend模板類，並且定義每個你20個可調用函數的兩個模板函數。這裏只有兩個foo和bar。

#include <iostream> 
using std::cout; 

template <typename Ctrl> 
class Frontend; 

template <typename Ctrl> 
void call_foo(typename Ctrl::WithFoo & ctrl) { ctrl.foo(); } 

template <typename Ctrl> 
void call_foo(Ctrl & ctrl) { Frontend<Ctrl>::default_foo(ctrl); } 

template <typename Ctrl> 
void call_bar(typename Ctrl::WithBar & ctrl) { ctrl.bar(); } 

template <typename Ctrl> 
void call_bar(Ctrl & ctrl) { Frontend<Ctrl>::default_bar(ctrl); } 

然後用可調用函數定義Frontend函數。在這裏，我將默認實現定義爲靜態成員，但這可以更改。

template <typename Ctrl> 
class Frontend 
{ 
public: 
    typedef Ctrl controller; 

    void foo() { call_foo<Ctrl>(c); } 
    void bar() { call_bar<Ctrl>(c); } 

    static void default_foo(Ctrl & ctrl) { cout<<"Default foo\n"; } 
    static void default_bar(Ctrl & ctrl) { cout<<"Default bar\n"; } 

private: 
    Ctrl c; 

}; 

最後，一些Controller類的例子。一個定義foo和bar，另一個定義每個只有一個。

struct CtrlFooBar 
{ 
    typedef CtrlFooBar WithFoo; 
    typedef CtrlFooBar WithBar; 
    void foo() { cout<<"CtrlFB foo\n"; } 
    void bar() { cout<<"CtrlFB bar\n"; } 
}; 

struct CtrlFoo 
{ 
    typedef CtrlFoo WithFoo; 
    void foo() { cout<<"CtrlFoo foo\n"; } 
}; 

struct CtrlBar 
{ 
    typedef CtrlBar WithBar; 
    void bar() { cout<<"CtrlBar bar\n"; } 
}; 

使用Frondtend所有這些類，並與int按預期工作。

int main() 
{ 
    Frontend<CtrlFooBar> c2; 
    Frontend<CtrlFoo> cf; 
    Frontend<CtrlBar> cb; 
    Frontend<int>  ci; 

    c2.foo(); 
    c2.bar(); 
    cf.foo(); 
    cf.bar(); 
    cb.foo(); 
    cb.bar(); 
    ci.foo(); 
    ci.bar(); 

    return 0; 
} 

---

輸出

CtrlFB foo 
CtrlFB bar 
CtrlFoo foo 
Default bar 
Default foo 
CtrlBar bar 
Default foo 
Default bar