有没有办法在非模板类中定义模板成员？

Question

假设我有一个名为 Compute 的类模板，以及另一个名为 Function_A 的类，并带有一个成员函数模板：

template <typename T> void Evaluate(T parameter)

我只能按原样使用Function_A 类。我已经知道T只能是type_1和type_2这两种类型之一。

有没有办法将类似于Compute<T> C 的东西作为Function_A 的成员变量，而不是在Evaluate(...) 内定义一个本地Compute<T> 对象？我知道这违反了使用模板的理念，因此这可能是不可能的，但理想情况下可以这样做吗？

我试图在Function_A 中拥有两个成员Compute<type_1> C1 和Compute<type_2> C2，然后在if (typeid(T) == typeid(type_1)) 下使用它们，但这很可怕，也违反了使用模板的理念。

只是为了说明我的意思：

template <class T>
class Compute
{
public:
  T Function_B(T parameter)
    {
      return f.eval(parameter);
    }

private:
  SomeClass<T> f;
}

还有一个班级：

class Function_A
{
  public:
    template <typename T> T Evaluate(T parameter)
    {
      Compute<T> C; //this is very expensive!
      T value = C.Function_B(parameter);
      return value;
    }

  private:
    double SomeParameter;
    //Compute<T> C; //conceptually what I want
}

Answer 1

怎么样（未经测试）：

class Function_A
{
  public:
    template <typename T> void Evaluate(T parameter)
    {
      T value = std::get<Compute<T>>(computers).Function_B(parameter);
      return T(SomeParameter) * value;
    }

  private:
    double SomeParameter;
    std::tuple<Compute<type_1>, Compute<type_2>> computers;
};

注意：std::pair 的工作方式与此处的 std::tuple 完全相同，如果您喜欢它添加的第一个/第二个语义。

另外，请注意 T(SomeParameter) 是 C 风格的转换，如果 T 不是类类型，这可能会出现问题。考虑T{} 或static_cast<T>()。

Answer 2

您可以做的一件事是制作C static。如果你有

template <typename T> void Evaluate(T parameter)
{
  static Compute<T> C; // only do this once per T now
  T value = C.Function_B(parameter);
  return T(SomeParameter)*value;
}

然后，当您使用 type_1 调用 Evaluate 时，您将拥有一个包含 C<type_1> 的函数版本，该版本仅在第一次调用该函数时构建，同样的事情发生在 @987654327 @。