嵌套模板参数时，我已经知道的类型名

Nested Template arguments when I know the typenames already

本文关键字：类型 参数 嵌套      更新时间：2023-10-16

在这种情况下，我有一个Algorithm类:

template <typename SourceType, typename DestType>
class Algorithm {
  bool apply() { ... return true;}
};

我试图创建一个Helper，从完全定义的Algorithm类抽象用户。这是我对实现的想法:

template <typename DataType, template <typename, typename> class AlgorithmType>
bool Helper(const DataType* soure, DataType* dest) {
  AlgorithmType<DataType, DataType> alg;
  return alg.apply();
}

Helper功能是否正确?有更好的方法吗?

这似乎是正确的。但是你的apply不返回任何东西，这是UB。

至于改进，您可以反转模板参数的顺序，并让DataType被推导出来:

template <template <typename, typename> class AlgorithmType, typename DataType>
bool Helper(const DataType* soure, DataType* dest) {
  AlgorithmType<DataType, DataType> alg;
  return alg.apply();
}

现在你可以用

Helper<Algorithm>(const_ptr, ptr);

你可以阻止第二个参数的演绎，使其更健壮:

template<typename T> struct identity{ using type = T; };
template<typename T>
using block_deduction = typename identity<T>::type;
template <template <typename, typename> class AlgorithmType, typename DataType>
bool Helper(const DataType* soure, block_deduction<DataType*> dest) {
  AlgorithmType<DataType, DataType> alg;
  return alg.apply();
}

现在你可以用

来调用它
Helper<Algorithm>(const_ptr, const_ptr);

Helper函数是正确的，但是您可能希望将typename DataType作为最后一个模板参数，以便可以从函数调用中推导出它:

template <template <typename, typename> class AlgorithmType, typename DataType>
bool Helper(const DataType* soure, DataType* dest) {
  AlgorithmType<DataType, DataType> alg;
  return alg.apply();
}

现在你可以这样使用Helper:

int main()
{
    const int* some_src_ptr = /*...*/;
    int* some_dst_ptr = /*...*/;
    Helper<SomeAlgorithmTemplate>(some_src_ptr, some_dst_ptr);
}

或者，您可以将整个算法作为模板参数传递，并让用户自行选择SourceType和DestType:

template <typename SourceType, typename DestType>
class Algorithm {
public:
  using source_type = SourceType;
  using dest_type = DestType;
private:
  bool apply() {}
};
template <typename Algo>
bool Helper(const typename Algo::source_type* soure, typename Algo::dest_type* dest) {
  Algo alg;
  return alg.apply();
}

现在你可以这样使用Helper:

int main()
{
    const int* some_src_ptr = /*...*/;
    int* some_dst_ptr = /*...*/;
    Helper<SomeAlgorithmTemplate<int, int>>(some_src_ptr, some_dst_ptr);
}

您也可以考虑使算法独立于编译时参数，并使用例如:

struct Algorithm {
   template <class Source, class Dest>
   bool operator()(Source source, Dest dest) {
       //...
       return something;
   }
};

然后:

template <class AlgType, typename DataType>
bool Helper(const DataType* soure, DataType* dest) {
  AlgType alg;
  return alg(source, dest);
}
运行:

Helper<Algorithm>(source_ptr, dest_ptr);
相关文章：