C++:类型别名中的递归依赖

Question

我想知道下面的代码是否正确。它在我的计算机上编译并运行，但我觉得 ShowValueClass 类型别名在 ValueClass 中定义有递归依赖性。您能解释一下编译器是如何解决这个问题的吗？

#include <iostream>

namespace tmp {
template <typename T>
struct ShowValueClass {
  void ShowValue() { std::cout << T::value << std::endl; }
};
} // namespace tmp

struct ValueClass {
  using ShowValueClass = tmp::ShowValueClass<ValueClass>;
  static constexpr int value = 42;
};

int main() {
  ValueClass::ShowValueClass s;
  s.ShowValue();
  return 0;
}

Answer 1

这里没有递归。你的类tmp::ShowValueClass<T>只适用于任何类型 T有成员(member)value cout 可以打印 (已定义权利 ostream& operator<<(ostream&, const T&))。

您添加了一个名为 ShowValueClass 的类型别名的事实里面ValueClass引用tmp::ShowValueClass<ValueClass>什么都没改变。在这种情况下，该类就像一个命名空间。

想想如果你提取 ShowValueClass 会发生什么来自 ValueClass :

struct ValueClass {
  static constexpr int value = 42;
};

using ShowValueClass = tmp::ShowValueClass<ValueClass>;

在那种情况下，您将访问 ShowValueClass直接在main()而不是在其前面加上 ValueClass:: ，就像你的情况一样。这两个事实 tmp::ShowValueClass使用 T::value并且类型别名 ShowValueClass在ValueClass 无关紧要(它们没有什么特别之处)。

将类本身用作模板类的模板参数的整个想法在 C++ 中很普遍。实际上，有一种称为 CRTP(奇怪的重复模板模式)的模式，其中类继承自模板类，使用类本身作为参数(来自维基百科):

// The Curiously Recurring Template Pattern (CRTP)
template<class T>
class Base
{
    // methods within Base can use template to access members of Derived
};
class Derived : public Base<Derived>
{
    // ...
};

您可以在此处查看整篇文章:https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern

一个真正的递归依赖示例

现在，为了完成这幅图，我可以向您展示一些由于递归定义而无法编译的代码:

template <typename T>
struct A {
   static constexpr int val = T::val;
};

struct B {
   static constexpr int val = A<B>::val;
};

int main() { }

在这里，A<T>::val取决于 T::val没关系，但是B::val取决于 A<B>::val扩展为 B::val .换句话说，B::val取决于 B::val ，这显然无法解决。这就像在说:

x := y(x)

与 y(x)是:

y(x) := x. 

因此，x := x .显然，无法确定 x 的值。 .

使用模板递归的工作示例

现在，如果正确地进行了递归并且定义了一个基本情况，显然它甚至可以用于计算非常复杂的事情。这是一个简单的例子:

#include <iostream>
using namespace std;

template <int N>
struct A {
   static constexpr int val = N + A<N - 1>::val;
};

template <>
struct A<0> {
   static constexpr int val = 0;
};

int main() {
   cout << A<10>::val << endl;
}

A<N>::val递归定义为:

N + A<N-1>::val if N != 0
0               if N == 0

因此，它是 0 中所有数字的总和至 N (含)。