Question

我一直在试验Curiously Recurring Template Pattern的通用单参数仿函数，并且有两个实现：一个使用模板模板参数工作，另一个我尝试访问派生的Functor :: type in接口类。在后一个例子中，编译器（gcc 5.4.0）报告

错误：'struct Cube＆lt;中没有名为'类型'的类型双＆gt;'

template<class T, template<class> class Functor>
class FunctorInterface_1 {
private:
  const Functor<T> &f_cref;
public:
  FunctorInterface_1() : f_cref(static_cast<const Functor<T>&>(*this)) {}
  T operator() ( T val ) const { return f_cref(val); }
}; // FunctorInterface_1 (works)

template<class Functor>
class FunctorInterface_2 {
private:
  const Functor &f_cref;
public:
  using Ftype = typename Functor::type;
  FunctorInterface_2() : f_cref(static_cast<const Functor&>(*this)) {}
  Ftype operator() ( Ftype val ) const { return f_cref(val); }
}; // FunctorInterface_2 (no type in Functor!)

然后我尝试使用以下两个类的main（）中的T = double进行编译：

template<class T> 
struct Square : public FunctorInterface_1<T,Square> {
  T operator()( T val ) const { return val*val; }
}; // Square


template<class T>
struct Cube : public FunctorInterface_2<Cube<T>> {
  using type = T; 
  T operator() ( T val ) const { return val*val*val; }
}; // Cube

可以将FunctorInterface_2 / Cube示例修改为工作，或是否有必要在T上模板化接口类在第一个例子中？谢谢！

编辑：使用gcc -std = c ++ 14，我可以得到第二个编译和运行的例子通过在FunctorInterface_1 :: operator（）中使用自动返回和参数类型，但是，据我所知，自动参数类型不是C ++ 14标准的一部分。

编辑2：我感觉有点厚。我刚刚意识到我可以在一个新参数上模板FunctorInterface_1 :: operator（），但是，对于我想到的应用程序，我真的希望我的基类能够访问派生类中定义的类型。

Answer 1

当行

using Ftype = typename Functor::type;

在基类中处理，Functor的定义不可用。因此，您无法使用Functor::type。

解决此限制的一种方法是定义特征类。

// Declare a traits class.
template <typename T> struct FunctorTraits;

template<class Functor>
class FunctorInterface_2 {
   private:
      const Functor &f_cref;
   public:

      // Use the traits class to define Ftype
      using Ftype = typename FunctorTraits<Functor>::type;

      FunctorInterface_2() : f_cref(static_cast<const Functor&>(*this)) {}
      Ftype operator() ( Ftype val ) const { return f_cref(val); }
}; // FunctorInterface_2 (no type in Functor!)

// Forward declare Cube to specialize FunctorTraits
template<class T> struct Cube;

// Specialize FunctorTraits for Cube
template <typename T> struct FunctorTraits<Cube<T>>
{
   using type = T; 
};

template<class T>
struct Cube : public FunctorInterface_2<Cube<T>> {
   using type = T; 
   T operator() ( T val ) const { return val*val*val; }
}; // Cube

工作代码：https://ideone.com/C1L4YW

Answer 2

您的代码可以简化为

template<typename TDerived> class
Base
{
    using Ftype = typename TDerived::type;
};

template<typename T> class
Derived: public Base<Derived<T>>
{
    using type = T;
};

Derived<int> wat;

它不起作用，因为在Base实例化时Derived类没有完成，编译器还没有意识到Derived::type的存在。

Answer 3

您必须了解实例化Cube<T> FunctionInterface_2<Cube<T>>时首先实例化。这意味着Cube<T>是一种不完整的类型，而这种情况正在发生因此，当编译器使用Ftype = typename Functor::type;进入该行时，Functor不完整，并且您无法访问其任何嵌套类型。

在您的情况下，您可以将FunctionInterface_2更改为：

template<class Functor>
class FunctorInterface_2 {
private:
    const Functor &f_cref;
public:
    FunctorInterface_2() : f_cref(static_cast<const Functor&>(*this)) {}
    template <class TT>
    auto operator() ( TT && val ) -> decltype(f_cref(val)) const { return f_cref(val); }
};

因此，现在访问有关Functor的信息会延迟，直到您从operator()致电FunctionInterface_2，此时FunctionInterface_2和Cube已完全实例化。

Answer 4

注意：@r-sahu已经回答了这个问题，但是我想对此进行详细说明，并具体解决clang的输出问题。

该问题可以在更小的代码示例中得到证明：（@ vtt suggested类似）

template <typename _CRTP>
struct A {
    using _C = typename _CRTP::C;
};

struct B : public A<B> {
    using C = int;
};

使用clang编译将导致完全误导的错误消息：（godbolt）

<source>:3:32: error: no type named 'C' in 'B'
    using _C = typename _CRTP::C;
               ~~~~~~~~~~~~~~~~^
<source>:6:19: note: in instantiation of template class 'A<B>' requested here
struct B : public A<B> {
                  ^
1 error generated.

GCC的错误消息更有帮助：（godbolt）

<source>: In instantiation of 'struct A<B>':
<source>:6:19:   required from here
<source>:3:33: error: invalid use of incomplete type 'struct B'
    3 |     using _C = typename _CRTP::C;
      |                                 ^
<source>:6:8: note: forward declaration of 'struct B'
    6 | struct B : public A<B> {
      |        ^

如已接受的答案所建议，实现特征类型可以解决此问题：

// this declaration must appear before the definition of A
template <typename _A>
struct a_traits;

template <typename _CRTP>
struct A {
    // `a_traits<_CRTP>::type` is an incomplete type at this point,
    // but that doesn't matter since `A` is also incomplete
    using _C = typename a_traits<_CRTP>::type;
};

// this specialization must appear before the definition of B
template <>
struct a_traits<struct B> { // adding the type specifier `struct` will declare B
    using type = int;
};

// specifying the template parameter will complete the type `A<B>`, which works since
// `a_traits<B>` is already complete at this point
struct B : public A<B> {
    using C = int;
};

在CTRP派生类中没有名为“type”的类型

4 个答案: