2

想象一个类（在VS2010中，这里没有可变参数模板对不起）

template <class Arg>
class FunctionWrapper
{
public:
       void Invoke(Arg arg){_fn(arg)};
private:
      std::function<void(Arg)> _fn;
}

然后我可以做例如

FunctionWrapper <int> foo; foo.Invoke(4);

这编译得很好。但这不会：

FunctionWrapper <void> foo; foo.Invoke();

现在，我可以使用模板专业化来解决这个问题。但我也想知道是否有办法让我以另一种方式解决这个问题......

template <class Arg>
class FunctionWrapper
{
public:
       void Invoke(void){_fn()};                    // }    overloaded
       void Invoke(Arg arg){_fn(arg)};              // }
private:
      std::function<void(Arg)> _fn;
}

即重载调用，然后回复条件编译，这样如果我实例化 FunctionWrapper<void>，带有参数的调用版本永远不会被编译。我确定我读过如何在现代 C++ 设计中做到这一点，但我不记得细节.....

4

1 回答 1

0

如果你试图以这种方式实现函子，那么设计中就会出现许多明显的缺陷。我假设，并且您似乎在评论中明确表示，该代码只是用于说明您的情况的示例。

以下是该问题的几个解决方案：

template<class T>
struct Trait{
    typedef T type;
    typedef T mock_type;
};
template<>
struct Trait<void>{
    typedef void type;
    typedef int mock_type;
};

template <class Arg>
class FunctionWrapper
{
public:
       void Invoke(void){_fn();}
       void Invoke(typename Trait<Arg>::mock_type arg){_fn(arg);}
       boost::function<void(typename Trait<Arg>::type)> _fn;
private:
};

template <class Arg>
class FunctionWrapper2
{
public:
    FunctionWrapper2(const boost::function<void(Arg)> arg) : Invoke(arg){}
    const boost::function<void(Arg)> Invoke;
};

int main(int argc, _TCHAR* argv[])
{

    FunctionWrapper<int> cobi;
    cobi._fn = &countOnBits<int>;
    cobi.Invoke(5);

    FunctionWrapper<void> cobv;
    cobv._fn = &func;
    cobv.Invoke();

    FunctionWrapper2<int> cobi2(&countOnBits<int>);
    cobi2.Invoke(5);

    FunctionWrapper2<void> cobv2(&func);
    cobv2.Invoke();
    //[...]
}

当然我并不是说我写的是好的代码，至于这个问题，它只是为了提供工作结构的例子。

您尝试的问题是，虽然函数 void Invoke(Arg arg){_fn(arg)}; 当您实例化 FunctionWrapper （并且不要尝试使用参数调用 Invoke 函数）时，实际上并没有被编译，它会被语法检查；当然 Invoke(void arg) 不是你的编译器会接受的！

这是我在stackoverflow上的第一个答案，我希望我一切都好；如果没有，请给我一些反馈，不要对我太生气:)

于 2013-06-27T13:18:33.223 回答