Question

我正在尝试在我的应用程序中实现一个简单的“管道和过滤器”类型的架构。对于具有一个输入和一个输出类型参数的所有过滤器，我将有一个公共基类。我会为所有过滤器注册下一个过滤器，因此它们形成一个简单的链。我有一个小问题：我应该如何将下一个过滤器的输出类型表示为类型参数（如prolog中的_？ - 下一个对象的输入应该与当前过滤器的输出匹配，但当前过滤器不应该知道输出类型下一个过滤器）。

class IFilter
{
    std::auto_ptr<TIn> params;
    IFilter *nextFilter;
public:
    typedef TIn TInType;
    typedef TOut TOutType;

    void SetParams(std::auto_ptr<TIn> param) {  ...irrelevant code... }
    virtual void Execute() = 0;
    void Register(IFilter<TOutType, ???> *filter) { ...irrelevant code... }
};

Answer 1

只需创建模板功能：

template <class In, class Out>
class Filter
{
public:
    template <class T>
    void Register(Filter<Out, T>*)
    {

    }
};

int main()
{
    Filter<int, float> f1;
    Filter<float, double> f2;
    f1.Register(&f2);
    return 0;
}

Answer 2

模板功能不起作用吗？

template<typename TIn, typename TOut>
struct Filter {
    template<typename NextTOut>
    void reg(Filter<TOut, NextTOut> *filter) {};
};

template<typename TIn, typename TOut>
struct Filter2 : Filter<TIn,TOut> {
};

template<typename TIn, typename TOut>
struct Filter3 : Filter<TIn,TOut> {
};

int main()
{
    Filter2<int,bool> f2;
    Filter3<bool,char> f3;

    f2.reg(&f3);

}

Answer 3

基本上，你所说的是

Filter<int, float> f1;
Filter<float, double> f2;

可以组成f1->f2，但不能组成f2->f1。这是相当微不足道的。这就是它的完成方式：

template<typename Tin, Tout>
class IFilter {
  // ...
  template<typename U>
  std::auto_ptr<IFilter<Tin, U> >
  operator->(std::auto_ptr<IFilter<Tout, U> > second) const
  {
    return std::auto_ptr<IFilter<Tin, U> >(
       new CompositeFilter(this, second));
  }
};

如果第一个文件管理器（Tout）的输出类型不是第二个过滤器的输入类型，编译器将会抱怨。在这种情况下，没有匹配的operator->。

可以是C ++中使用的任意模板参数吗？

3 个答案: