Functor——转发

Functor是自己定义了operator()并可以执行某任务的家伙，它应该是这样的：

template    <typename ResultType>
class Functor
...{
public:
    ResultType    operator()();
private:
};

 但是这有一个问题，我们希望它可以接受参数序列，幸好有typelist得支持：

template    <typename ResultType,class TList>
class    Functor
...{

};

为了避免暴露更多的细节，我们使用handle-body（Bridge）封装Functor：

template    <typename R,class TList>

class    FunctorImpl;

 

template    <typename R,class TList>
class    Functor
...{
public:
    Functor();
    Functor(const Functor&);
    Functor&    operator=(const Functor&);
    explicit    Functor(std::auto_ptr<Impl>    spImpl);
private:
    typedef    FunctorImpl<R,TList>    Impl;
    std::auto_ptr<Impl>        spImpl_;
};

我们来讨论Functor对operator()的支持。

转发：

template    <typename R,class TList>
class    Functor
...{
    typedef    TList    ParmList;
    typedef    typename TypeAtNonStrict<TList,0,EmptyType>::Result    Parm1;
    typedef    typename TypeAtNonStrict<TList,1,EmptyType>::Result    Parm2;
    ...
public:
    R    operator()
    ...{
        return    (*spImpl_)();
    }
    R    operator(Parm1 p1)
    ...{
        return    (*spImpl_)(p1);
    }
    R    operator(Parm1 p1,Parm2 p2)
    ...{
        return    (*spImpl_)(p1,p2);
    }
};

这太可怕了，对于参数无限的情况，这个地方不知道要写多少，但是，请让我们假设这个上限不会太大，而且假定它是某个具体的值，要不这个问题将会很难办，正如typelist的宏一样，假定一个数字，不要一切都完美理想化。

是的，这在编译的时候没问题，但是使用的时候只有一个是正确的，没问题，你永远都在使用那一个正确的，除非你不想编译通过。

到此只差一个FunctorImpl没有处理。