c++ - SFINAE 启用/禁用功能和模板别名

Question

我想知道如何实现我在下面描述的内容。
考虑一个 CRTP 基类，其中一个功能需要启用，另一个功能需要禁用。
这是通过依赖于类型定义的特征类来控制的。
我最好不想在我的 traits 类中定义任何东西，但如果它有助于将它定义为 void，我可以接受。评论中的更多信息，因为在那里更容易展示我想要实现的目标。

template<class T>
struct Model_Traits;

// Base CTRP class
template<typename Model>
class BaseModel
{
  inline const Model& impl() const { return static_cast<Model const&>(*this); }

  // not sure how to enable this template or not based on my traits class
  // which is necessary as some wont have it defined
  using foo_t = typename Model_Traits<Model>::foo_t;

  // this one should be enabled when foo_t is not defined
  void optimize(const foo1& f1, const foo2& f2, foo3* f3)
  {
    impl().optimize(f1,f2,f3);
  }

  // this one should only be enabled if foo_t is defined
  // not sure if this is correct
  template<typename T = foo_t,
           typename = std::enable_if<foo_t>::type>
  void optimize(const foo1& f1, const foo2& f2, foo3* f3, foo_t* f4)
  {
    impl().optimize(f1,f2,f3, f4);
  }
}

// First class defining the foo_t
template<MyModel>
struct Model_Traits
{
   using foo_t = myFoo;
}

class MyModel : public BaseModel<MyModel>
{
   void optimize(const foo1& f1, const foo2& f2, foo3* f3, foo_t* f4);
}

// Second class not defining foo_t
template<MyModel2>
struct Model_Traits
{

}

class MyModel2 : public BaseModel<MyModel2>
{
   void optimize(const foo1& f1, const foo2& f2, foo3* f3);
}

我当然应该说这是简化的，我的代码看起来不像那样，但如果你把所有其他东西都去掉，它就非常接近了。

有什么想法吗？

Answer 1

我们可以通过几个步骤完成此操作。首先，如果 foo_t 是使用 void_t 定义的，则创建一个类型特征:

template <typename...>
using void_t = void;

template <typename T, typename = void>
struct has_foo_t : std::false_type { };

template <typename T>
struct has_foo_t<T, void_t<typename T::foo_t>> : std::true_type { };

然后我们将使用它来将我们的optimize 函数转发到 SFINAE 友好的上下文中:

template <typename Model>
class BaseModel {
public:
    template <typename... Args>
    void optimize(Args&&... args) {
        optimize_impl<Model>(std::forward<Args>(args)...);
    }
};

我们将有两个 impl 函数:一个 enabled 和一个 disabled:

template <typename T,
          typename = std::enable_if_t<has_foo_t<T>::value>>
void optimize_impl(const foo1& f1, const foo2& f2, foo3* f3, typename T::foo_t* f4)
{ .. }

template <typename T,
          typename = std::enable_if_t<!has_foo_t<T>::value>>
void optimize_impl(const foo1& f1, const foo2& f2, foo3* f3)
{ .. }

即使 T 在这种情况下是 Model，我们仍然需要它作为函数模板参数，以便允许替换失败是“软”失败而不是硬失败编译错误。