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个功能：一个enable d和一个disable d：

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，我们仍然需要将其作为函数模板参数，以便允许替换失败为＆＃34; soft＆＃34;失败而不是硬编译错误。

Answer 2

您的代码中存在概念上的错误，因为您将类型提供给std::enable_if类的第一个参数（而它应该是布尔值）：

typename = std::enable_if<foo_t>::type
  ...

（此外，typename）前面缺少std::enable_if

因此，您的traits类应该包含一个static constexpr bool而不是一个类型，它表示是否应该启用该函数：

static constexpr bool enable_foo = Model_Traits<Model>::enable_foo;

然后您可以传递给std::enable_if（或更方便：std::enable_if_t - 该别名让您忘记了typename和::type ）。

派生自`std :: enable_if`

另一个直接解决方法是从std::enable_if

派生您的Traits类

template<T>
struct Model_Traits : public std::enable_if<false> {}

template<>
struct Model_Traits<MyModel> : public std::enable_if<true, myFoo> {}

template<>
struct Model_Traits<MyModel2> : public std::enable_if<false>
{
    //in principle you don't need to restate that, just for clarity
}

然后通过

使用它

  template<typename T = foo_t,
           typename = typename Model_Traits<T>::type>
  void optimize(const foo1& f1, const foo2& f2, foo3* f3, foo_t* f4)
  {
      impl().optimize(f1,f2,f3, f4);
  }

这将仅为MyModel启用此功能，但不会为MyModel2启用此功能。

使用`void_t`

此外，正如评论中所提到的，在更现代的风格中，您还可以使用void_t：

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

struct A {};

struct B
{
    using foo_t=double;    
};

struct C
{
    template<typename T, typename = void_t<typename T::foo_t> >
    void foo(T const& t)
    {
        std::cout<<"hello"<<std::endl;
    }
};

int main()
{
    //C{}.foo(A{});  //compile time-error
    C{}.foo(B{});    //ok, prints "hello"
}

DEMO

这个可能是最直接的选择。另请参阅some related threads on SO。

Answer 3

您可以创建您的特征：

namespace detail
{
    template <typename T>
    decltype(std::declval<typename T::foo_t>(), std::true_type{}) has_foo_t_impl(int);

    template <typename T>
    std::false_type has_foo_t_impl(...);
}

template <typename T>
using has_foo_t = decltype(detail::has_foo_t_impl<T>(0));

然后创建一个帮助类：

template<typename Model, bool = has_foo_t<Model>>
struct BaseModelOptimizeHelper;

template<typename Model>
struct BaseModelOptimizeHelper<Model, true>
{
    void optimize_impl(const Model& model, const foo1& f1, const foo2& f2, foo3* f3, foo_t* f4){
        model.optimize(f1,f2,f3, f4);
    }
};

template<typename Model>
struct BaseModelOptimizeHelper<Model, false>
{
    void optimize_impl(const Model& model, const foo1& f1, const foo2& f2, foo3* f3)
    {
        model.optimize(f1,f2,f3);
    }
};

最后：

template<typename Model>
class BaseModel : protected BaseModelOptimizeHelper<Model>
{
    const Model& impl() const { return static_cast<Model const&>(*this); }
public:
    template <typename ... Ts>
    void optimize(Ts&&... ts) { optimize_impl(impl(), std::forward<Ts>(ts)...); };

};

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

3 个答案:

派生自`std :: enable_if`

使用`void_t`