所有重载方法的别名?

Alias for all overloaded methods?

我有一个 class Filter 方法 process 为各种输入重载。

template< typename T >
class Filter
{ 
public:
    void process(T arr[], size_t len);
    T process(T one_value);
    void process(std::array &arr);
    void process(std::vector &v);
    //... many other variants

    using operator() = process;  // How to write proper?
}

我想简化省略 process 的用户代码:filter.process(values) 将变为 filter(values)。我不认为为每个变体写一个重载的 operator() 是个好主意。一定有更方便的解决方案吧?

因为您已经有了模板;为什么不试试可变参数模板呢;

template <typename... Args>
auto operator()(Args&&... args)
// assuming non-reference returns
{
  return process(std::forward<Args>(args)...);
}

或者;如果从某些重载返回引用(OP 中未显示);

template <typename... Args>
decltype(auto) operator()(Args&&... args)
// caters for reference returns
{
  return process(std::forward<Args>(args)...);
}

为了进一步的完整性和更广泛的用例;如果需要,以下提供 SFINAE 友好的行为,并且根据编译器,shorter/easier 错误消息;

template <typename... Args>
auto operator()(Args&&... args) -> decltype(process(std::forward<Args>(args)...))
// SFINAE support using a trailing decltype
{
  return process(std::forward<Args>(args)...);
}

当然,只需模板化 operator(),使用通用参考,perfect-forward process 的参数。当然,您需要添加适当的 header.

template< typename T >
class Filter
{ 
public:
    void process(T arr[], size_t len);
    T process(T one_value);
    void process(std::array &arr);
    void process(std::vector &v);
    //... many other variants

    template<typename... Y>
    auto operator () (Y&&... y)
        -> decltype(process(std::declval<Y>()...))
    {
         return process(std::forward<Y>(y)...);
    }
}

但是,请注意 process 的每个重载都必须在 operator ()(...) 之前声明 - 谢谢 T.C

好的,您编辑了问题,所以这回答了您现在的问题,具体来说,"I want to simplify the user code omitting process: filter.process(values) will become filter(values)."

只需将所有这些重载改为构造函数,如下所示:

template< typename T >
class Filter
{ 
public:
    void Filter(T arr[], size_t len);
    T Filter(T one_value);
    void Filter(std::array &arr);
    void Filter(std::vector &v);
    //... many other variants
};