Create your own functor,C++

Question

I want to create a functor like std::plus<>() but also add std::clamp functionality to it. Let's say it is a function plus_clamp<>(T MIN = numeric_limits<T>::min(), T MAX = ...max()) I started to look what implementation does std::plus<>() have, and tried to repeat it.

So I wrote something like this.

struct plus_clamp {
    template<typename T = void>
    constexpr T operator()(const T& lhs, const T& rhs, T MIN = nl::min(),T MAX = nl::max()) {
        T result = std::plus<>();
        result = std::clamp(result, MIN,MAX);
        return result;
    }
};

But when I try to use that function with std::transform(a.begin(),a.end(),b.begin(),result.begin(), plus_clamp<>())

I get compiler error error: expected '(' for function-style cast or type construction error: expected expression(at template parameter arg) error: expected expression(at function arguments)

I know that I am doing that wrong as I need to pass the template argument and the function arguments explicitly, but then this raises the question how is std::plus<>() implemented so it skips the template and function arguments?

`plus_clamp` itself is not a template. Remove the `<>`: `std::transform(a.begin(),a.end(),b.begin(),result.begin(), plus_clamp())`. Voting to close as typo — 463035818_is_not_an_ai, Dec 03 '20 at 20:44
its `operator()` is a template, but the template parameters can be deduced from the paramters — 463035818_is_not_an_ai, Dec 03 '20 at 20:44
thanks, but now it complains ```error: no viable conversion from 'std::plus<>' to 'int' T result = std::plus<>();``` — Hrant Nurijanyan, Dec 03 '20 at 20:47
well no sorry, retracted close vote. You know that it is wrong already, but your interpretation is also wrong ;) and deserves an explanation — 463035818_is_not_an_ai, Dec 03 '20 at 20:47
so how can I interpret that right? :D that was the part of the question)) — Hrant Nurijanyan, Dec 03 '20 at 20:48
@NathanOliver I did it ```T result = std::plus<>(lhs,rhs);``` but now it says ```error: no matching constructor for initialization of 'std::plus<>' T result = std::plus<>(lhs,rhs);``` — Hrant Nurijanyan, Dec 03 '20 at 20:55
@NathanOliver I tried to remove ```<>``` but then it says no conversion from void to int — Hrant Nurijanyan, Dec 03 '20 at 20:56
You need `std::plus<>{}(lhs,rhs);` so that you create an object of `std::plus` and then use it's `operator()` — NathanOliver, Dec 03 '20 at 20:57

463035818_is_not_an_ai · Answer 1 · 2020-12-03T21:04:03.957

Your plus_clamp is not a template. Hence you need to remove the <>:

std::transform(a.begin(),a.end(),b.begin(),result.begin(), plus_clamp())
                                                                  // ^

std::plus<T> on the other hand is a template. It has an operator():

constexpr T operator()( const T& lhs, const T& rhs ) const;

You can either explitly select the type to add via:

T result = std::plus<T>()(lhs,rhs);
                   //^  T == int in your example
                      //^ create instance 
                        //^ call its operator()

or you use the default std::plus<> which is std::plus<void>. It has a operator() that deduces the type from its parameters:

T result = std::plus<>()(lhs,rhs);

Complete example

Alan Birtles · Accepted Answer · 2020-12-03T21:12:06.777

1

There are a number of issues in your code.

There is no way to pass the clamp values into the operator (if using std::transform), you need to pass them as constructor parameters to plus_clamp. This then means that plus_clamp needs to be a template rather than the operator.
Assuming nl is std::numeric_limits it is a template so needs the template type passed to it: std::numeric_limits<T>::min()
std::plus<>() just constructing the type and not calling its operator. It should be std::plus<>{}(lhs, rhs)
When calling std::transform you pass plus_clamp<>(), in your original code plus_clamp isn't a template so you just need plus_clamp().

A fully working example would be:

#include <algorithm>
#include <functional>
#include <limits>

template<typename T = void>
struct plus_clamp {
    constexpr plus_clamp(T MIN = std::numeric_limits<T>::min(),T MAX = std::numeric_limits<T>::max())
    : MIN(MIN), MAX(MAX)
    {
    }

    constexpr T operator()(const T& lhs, const T& rhs) {
        T result = std::plus<>{}(lhs, rhs);
        result = std::clamp(result, MIN,MAX);
        return result;
    }

    T MIN;
    T MAX;
};

int main()
{
    std::vector<int> a,b, result;
    std::transform(a.begin(),a.end(),b.begin(),result.begin(), plus_clamp<int>(10, 100));
}

If you are using c++17 you can use class template argument deduction and just use plus_clamp(10, 100).

edited Dec 03 '20 at 21:12

answered Dec 03 '20 at 21:01

Alan Birtles

32,622
4
31
60

actually it seems I cannot have syntax like ```std::plus<>()``` – Hrant Nurijanyan Dec 03 '20 at 21:07
@HrantNurijanyan why not? Here `std::plus<>{}(lhs, rhs);` is the same as `std::plus<>()(lhs, rhs);` – 463035818_is_not_an_ai Dec 03 '20 at 21:07
yep, I just used braces to disambiguate between creating the functor and calling it – Alan Birtles Dec 03 '20 at 21:08
because when I skip the template for ```plus_clamp<>``` it cannot have constructor with ```constexpr plus_clamp(void MIN = std::numeric_limits::min(),... ``` – Hrant Nurijanyan Dec 03 '20 at 21:12
if you're using c++17 you can just omit the template arguments (assuming your clam values are the same type as your vector elements) – Alan Birtles Dec 03 '20 at 21:13

Create your own functor,C++

2 Answers2