C++ 类型列表的Loki IndexOf的实现

我是基于Loki，基于阅读以下内容，实现了一个类型列表：

并在IndexOf（在类型列表中查找类型的索引）的站点上看到了以下代码：

模板
结构IndexOf
{
枚举{value=-1}；
};
模板
结构索引
{
私人：
枚举{temp=IndexOf:：value}；
公众：
枚举{value=（temp==-1）？-1:1+temp}；
};

这似乎不起作用，因为在递归遍历列表的过程中，我看不到任何东西在比较t。在我的实现中，它如下所示：

template<typename Tlist, typename T>
struct IndexOf
{
private:
  static const int temp = IndexOf<typename Tlist::Tail, T>::value;
public:
  static const int value = (temp == -1) ? -1 : 1 + temp;
};

template<typename T>
struct IndexOf<NullType, T>
{
  static const int value = -1;
};

模板
结构索引
{
私人：
静态常量int temp=IndexOf:：value；
公众：
静态常量int值=（温度==-1）？-1:1+温度；
};
模板
结构索引
{
静态常量int值=-1；
};

事实上，总是返回-1。如果我想到它，想象一个人有一个类型列表；然后Tail将是NullType，所以temp将被专门化为-1，然后值将是-1。即使Head是char，我也会期望为零。我错过了什么

谢谢

---

我对Typelist的实现仅仅是：

template<typename H, typename T>
struct Typelist
{
  typedef H Head;
  typedef T Tail;
};

模板
结构类型表
{
H型头；
T型尾；
};

我猜这不是Lokis，但Joel的回答让我明白了这一点：

template<typename Head, typename Tail, typename T>
struct IndexOfImpl
{
private:
  static const int temp = IndexOfImpl<typename Tail::Head, typename Tail::Tail, T>::value;
public:
  static const int value = (temp == -1) ? -1 : temp + 1;
};

template<typename T, typename Tail>
struct IndexOfImpl<T, Tail, T>
{
  static const int value = 0;
};

template<typename T>
struct IndexOfImpl<T, NullType, T>
{
  static const int value = 0;
};

template<typename Head, typename T>
struct IndexOfImpl<Head, NullType, T>
{
  static const int value = -1;
};

template<typename Tlist, typename T>
struct IndexOf
{
 public:
  static const int value = IndexOfImpl<typename Tlist::Head, typename Tlist::Tail, T>::value;
};

模板
结构IndexOfImpl
{
私人：
静态常量int temp=IndexOfImpl:：value；
公众：
静态常量int值=（温度==-1）？-1:temp+1；
};
模板
结构IndexOfImpl
{
静态常量int值=0；
};
模板
结构IndexOfImpl
{
静态常量int值=0；
};
模板
结构IndexOfImpl
{
静态常量int值=-1；
};
模板
结构索引
{
公众：
静态常量int value=IndexOfImpl:：value；
};

应该是：

template <class T>
struct IndexOf< NullType, T>
{
    enum { value = -1 };
};

template <class T, class Head, class Tail>
struct IndexOf< Typelist<Head, Tail>, T>
{
private:
    enum { temp = IndexOf<Tail, T>::value };
public:
    enum { value = (temp == -1) ? -1 : 1+temp };
};

template <class T, class Tail>
struct IndexOf< Typelist<T, Tail>, T>
{
public:
    enum { value = 0 };
};

模板
结构IndexOf
{
枚举{value=-1}；
};
模板
结构索引
{
私人：
枚举{temp=IndexOf:：value}；
公众：
枚举{value=（temp==-1）？-1:1+temp}；
};
模板
结构索引
{
公众：
枚举{value=0}；
};

您试图在列表的递归编码中的某个头部找到T。

应该是：

template <class T>
struct IndexOf< NullType, T>
{
    enum { value = -1 };
};

template <class T, class Head, class Tail>
struct IndexOf< Typelist<Head, Tail>, T>
{
private:
    enum { temp = IndexOf<Tail, T>::value };
public:
    enum { value = (temp == -1) ? -1 : 1+temp };
};

template <class T, class Tail>
struct IndexOf< Typelist<T, Tail>, T>
{
public:
    enum { value = 0 };
};

模板
结构IndexOf
{
枚举{value=-1}；
};
模板
结构索引
{
私人：
枚举{temp=IndexOf:：value}；
公众：
枚举{value=（temp==-1）？-1:1+temp}；
};
模板
结构索引
{
公众：
枚举{value=0}；
};

---

您试图在列表的递归编码中找到T。

谢谢！从我简单的Typelist实现中，我不得不将其翻译成上面的内容（编辑我的答案），谢谢！从我对Typelist的简单实现中，我必须将此转换为上面的内容（编辑我的答案），您不需要这个案例。你当时有什么含糊不清的地方吗？你不应该需要这个案子。那你有什么含糊不清的地方吗？