如何将Configuration模板类作为模板参数传入另一模板类并使用其类型别名

现有代码定义与验证 #

Configuration模板类 #

template<
  typename VariableType,
  size_t StateSize,
  template<size_t, typename> typename IntegrationStrategy
>
class Configuration {
public:
  using State = std::array<VariableType, StateSize>;
  using Strategy = IntegrationStrategy<StateSize, VariableType>;
  using Var = VariableType;
};

验证特化正确性 #

template <size_t StateSize, typename VariableType>
class RungeKutta4 {};

// 特化Configuration并验证类型别名
using Conf = Configuration<double, 5, RungeKutta4>;

static_assert(std::is_same_v<double, Conf::Var>);
static_assert(std::is_same_v<std::array<double, 5>, Conf::State>);
static_assert(std::is_same_v<RungeKutta4<5, double>, Conf::Strategy>);

尝试过的错误写法及编译报错 #

写法一：直接用模板作为参数 #

template <Configuration Conf>
class DifferentialEquation {
public:
  void dummy(const Conf::State& state) {}
};

写法二：模板模板参数未实例化 #

template <template<
  typename,
  size_t,
  template<size_t, typename> typename> typename Conf>
class DifferentialEquation {
public:
  void dummy(const Conf::State& state) {}
};

编译错误信息 #

\DifferentialEquation.hpp(22): error C3205: argument list for template template parameter 'Conf' is missing
  /DifferentialEquation.hpp(40): note: see reference to class template instantiation 'DifferentialEquation<Conf>' being compiled
\DifferentialEquation.hpp(22): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
\DifferentialEquation.hpp(22): error C2144: syntax error: 'unknown-type' should be preceded by ')'
\DifferentialEquation.hpp(22): error C2144: syntax error: 'unknown-type' should be preceded by ';'
\DifferentialEquation.hpp(22): error C2039: 'State': is not a member of '`global namespace''
\DifferentialEquation.hpp(22): error C2143: syntax error: missing ';' before '&'
\DifferentialEquation.hpp(22): error C2059: syntax error: ')'
\DifferentialEquation.hpp(22): error C2334: unexpected token(s) preceding '{'; skipping apparent function body
  ninja: build stopped: subcommand failed.

尝试命名模板参数但仍错误 #

template <template<
  typename X,
  size_t Y,
  template<size_t, typename> typename Z> typename Conf>
class DifferentialEquation {
public:
  void dummy(const Conf::State<X, Y, Z>& state) {} // error
  void dummy(const Conf<X, Y, Z<Y, X>>::State& state) {} // error
};

正确解决方案 #

核心思路 #

你需要的是已经实例化完成的Configuration类型（如Configuration<double,5,RungeKutta4>），而非模板本身。因此只需将DifferentialEquation的模板参数定义为任意类型，再通过typename访问其内部依赖类型别名。

正确代码实现 #

#include <array>
#include <type_traits>

// 原Configuration类保持不变
template<
  typename VariableType,
  size_t StateSize,
  template<size_t, typename> typename IntegrationStrategy
>
class Configuration {
public:
  using State = std::array<VariableType, StateSize>;
  using Strategy = IntegrationStrategy<StateSize, VariableType>;
  using Var = VariableType;
};

template <size_t StateSize, typename VariableType>
class RungeKutta4 {};

// 正确的DifferentialEquation定义
template <typename Conf>
class DifferentialEquation {
public:
    // 必须用typename声明Conf::State是类型（依赖名称）
    void dummy(const typename Conf::State& state) {}
};

// 使用示例
int main() {
    using MyConf = Configuration<double, 5, RungeKutta4>;
    DifferentialEquation<MyConf> eq;
    
    // 验证类型正确性
    static_assert(std::is_same_v<typename MyConf::State, std::array<double,5>>);
    return 0;
}

可选：限定模板参数必须是Configuration的特化 #

如果想确保传入的Conf一定是Configuration的实例，可以用static_assert做编译期检查：

template <typename Conf>
class DifferentialEquation {
    // 检查Conf是否包含所需的类型别名
    static_assert(std::is_same_v<typename Conf::Var, typename Conf::State::value_type>, 
                  "Conf must be a Configuration specialization");

public:
    void dummy(const typename Conf::State& state) {}
};

C++20及以上版本可使用Concept做更优雅的限定：

template <typename T>
concept ConfigurationType = requires {
    typename T::Var;
    typename T::State;
    typename T::Strategy;
    // 额外检查State的类型是否符合预期
    requires std::is_same_v<typename T::State, std::array<typename T::Var, std::tuple_size_v<typename T::State>>>;
};

template <ConfigurationType Conf>
class DifferentialEquation {
public:
    // 此时无需typename，因为Concept已确保Conf::State是类型
    void dummy(const Conf::State& state) {}
};

内容的提问来源于stack exchange，提问作者Jepessen