c++ - 如果可用，使用模板参数的实现，否则默认

Question

我想创建一个 Frontend不同的模板类 Controller秒。 Frontend应该使用 Controller方法的实现(如果可用(即支持某个功能))，否则为默认方法，如

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

• Frontend将在内部使用类型特征来了解更多关于 Controller 的信息,
• Controller 不需要它从提供默认实现的任何基类派生，因为默认方法实现将需要私有(private)信息 Frontend .

Controller 中可能会实现大约 20 种方法.我试图创建(嵌套的)特征来提供有关所提供实现的信息:

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

所以 Controller::supportsFeature<>必须提供以告知具体实现。 ::type是std::true_type如果 Controller 支持功能或 std::false_type如果没有。为此，我创建了一个禁用任何功能的默认结构，因此 Controller 类必须显式启用它提供的任何功能。这似乎是一种携带来自 Controller 的信息的舒适方式。到 Frontend , 但它有两个主要缺点:

1. 其他人(最终会提供 Controller )很难实现 supportsFeature , 因为必须编写嵌套特征类的特化

2. 我不确定应该如何评估 Frontend::something() 中是否存在某项功能，因为没有参数取决于该功能的存在 - 我无法提供合理表达的重载(我不想为 std::true_type 与 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 */ }
};