Alias for all overloaded methods?

Question

I have a class Filter which has the method process overloaded for various inputs.

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?
}

I want to simplify the user code omitting process: filter.process(values) will become filter(values). I don't think that writing an overloaded operator() for every variant is good idea. There must exist a more convenient solution?

Answer 1

Since you already have templates in the mix; why not try a variadic template as well;

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

Alternatively; if references are returned form some of the overloads (not shown in the OP);

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

---

For further completeness and broader use cases; if desired, the following offers SFINAE-friendly behaviour and depending on the compiler, shorter/easier error messages;

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)...);
}