有没有绑定template<template>参数的方法？

Question

上下文

我有一个自定义的比较器，它接受另一个比较器并应用额外的检查：

template <template <typename> class Comparator, typename T>
struct SoftOrder : public std::binary_function<T, T, bool> {
    bool operator()(const T lhs, const T rhs) const {
        return Comparator<T>()(lhs, rhs) && AnotherCheck();
    }
};

我有第二个接受比较器的类，例如：

template <template <typename> class Comparator>
class Processor { ... };

使用标准比较器(例如std::less)实例化Processor很容易，如下所示：

Processor<std::less> processor1;
Processor<std::greater> processor2;

然而，使用SoftOrder实例化并不那么容易，因为编译器会正确地抱怨缺少第二个模板参数：

Processor<SoftOrder<std::less> > processor3; // <-- Fails to compile

当前解决方案

在发布这个问题之前，我已经想出了一些解决方案。

第一个解决方案-大量的派生类

template <typename T>
struct SoftOrderLessThan : public SoftOrder<std::less, T> {};

template <typename T>
struct SoftOrderGreaterThan : public SoftOrder<std::greater, T> {};

这种解决方案的主要缺点是每次需要新的变体时都需要创建新的结构，例如：

template <typename T>
struct SoftOrderLessThan : public SoftOrder<std::less, T> {}; // Never used after the next line.
Processor<SoftOrderLessThan> processor3;

第二种解决方案--一个非常具体的绑定类

template <template <typename> class Comparator>
struct BindToSoftOrder {
    template <typename T>
    struct type : public SoftOrder<Comparator, T> {};
};

这稍微好一点，因为我们不需要显式地创建中间类：

Processor<BindToSoftOrder<std::less>::type> processor3;

缺点是需要一个专门针对这种情况的类，这不能通过将SoftOrder作为BindToSoftOrder上的模板参数来真正泛化，因为这将使其成为标准不允许的template<template<template>>>。

第三种解决方案- C++11模板别名

template <typename T>
using SoftOrderLessThan = SoftOrder<std::less, T>;

它比第一种方法更好，因为它不需要引入新的类，但是仍然需要使用这些额外的代码，这些代码只用于传递给另一个模板类：

template <typename T>
using SoftOrderLessThan = SoftOrder<std::less, T>; // Never used again
Processor<SoftOrderLessThan> processor3;

最后，问题是

有没有一种通用的方法来将我的自定义比较器绑定到一个特定的比较器，如下所示？

Processor<SomeCoolMetaTemplateBind<SoftOrder, std::less>::type> processor3;

我相信如果所有的模板参数都是简单的类型，我可以做一些像Processor<boost::mpl::bind<SoftOrder, std::less> >这样的事情，但是模板参数列表中模板类型的存在阻止了这种情况的发生。

理想的解决方案应该包括C++03，但我也很高兴听到C++11的解决方案。

如果不可能，我希望这个问题至少是有趣的。

Answer 1

看起来这是可行的：

template <
  template <template <typename> class,class> class U,
  template <typename> class X
>
struct SomeCoolMetaTemplateBind {
  template <typename T>
  struct type : public U<X,T> {
  };
};