How to properly define function objects in c++?

Question

I am getting a very strange error on a very simple code that I couldn't fix.

I have defined the following function object:

template<const size_t n> class L2Norm {
    public:
            double operator()(const Point<n>& p) {
                /* computes the L2-norm of the point P ... */

            }
            double operator()(const Point<n>& p,
                            const Point<n>& q) {
                    return L2Norm<n>(p-q);
            }
};

Here the class Point<n> is well defined before to store the n coordinates of a point in n-dimensional space (with required operators, ...).

I expect to get the l2-norm of a point p (created as Point<5> p for example) using L2Norm<5>(p). But this gives me the following error:

no matching function for call to ‘L2Norm<5ul>::L2Norm(Point<5ul>&)’
note: candidates are: L2Norm<n>::L2Norm() [with long unsigned int n = 5ul]
note:   candidate expects 0 arguments, 1 provided
note: L2Norm<5ul>::L2Norm(const L2Norm<5ul>&)
note:   no known conversion for argument 1 from ‘Point<5ul>’ to ‘const L2Norm<5ul>&’

I'm pretty sure that I am doing a very stupid mistake but I cannot find out where!

P.S. As a side question, it would be much nicer if I could say L2Norm(p) only and the compiler detects the template parameter from p but to the best of my knowledge this is not possible. Am I right?

You forgot to instantiate the object: `L2Norm<5> norm; norm(p);`. — BartoszKP, Sep 30 '13 at 10:55
It's indeed all in the name: function **object**. This is just a **class**. — MSalters, Sep 30 '13 at 20:44

juanchopanza · Answer 1 · 2013-09-30T11:01:40.007

7

You need to create an instance and call its operator (). Currently you are trying to call a non-existent converting constructor.

return L2Norm<n>()(p-q); // C++03 and C++11
//              ^^

or

return L2Norm<n>{}(p-q);  // c++11
//              ^^

As an aside, you might want to make your call operators const too, since it is unlikely calls to them should result in a change to the observable state of an instance:

template<const size_t n> class L2Norm 
{
 public:
  double operator()(const Point<n>& p) const { .... }
  double operator()(const Point<n>& p, const Point<n>& q) const { .... }
};

edited Sep 30 '13 at 11:01

answered Sep 30 '13 at 10:55

juanchopanza

223,364
34
402
480

Thanks a lot. I thought the `operator()` can be used as a static member. – MikeL Sep 30 '13 at 10:59
@ManiBastaniParizi: You didn't declare it as such. But I am not sure it would work even if you did. – Jan Hudec Sep 30 '13 at 10:59
You are absolutely right. However, it apparently turns out it is not possible to declare the `operator()` as `static` (I just tried it out and got errors!). – MikeL Sep 30 '13 at 11:01
@ManiBastaniParizi: You get into parsing problems. `L2Norm()` is a default-constructed `L2Norm` temporary (cf. `std::string()`, the empty string). For that reason alone you can't overload `operator()` as a `static` member. – MSalters Sep 30 '13 at 20:49

score 2 · Answer 2 · edited Sep 30 '13 at 20:52

As @juanchopanza's already answered, you have to create the object first:

L2Norm<5>()(p-q);

Now, you can even get:

L2Norm()(p-q)

using so called "polymorphic function object". By making a simple class type with template operator() instead:

class L2Norm {
public:
    template<const size_t n> 
    double operator()(const Point<n>& p) const {
        /* computes the L2-norm of the point P ... */
    }
    template<const size_t n> 
    double operator()(const Point<n>& p,
                      const Point<n>& q) const {
        return operator()(p-q);
    }
};

The disadvantage is that you can't make this an adaptable binary function for C++03, so it will not work in some C++03 algorithms. In boost it will if you provide appropriate definitions and in C++11 it should be handled thanks to use of decltype.

With this technique, you can eliminate the redundant () :

class {
public:
    template<const size_t n> 
    double operator()(const Point<n>& p) const {
        /* computes the L2-norm of the point P ... */
    }
    template<const size_t n> 
    double operator()(const Point<n>& p,
                      const Point<n>& q) const {
        return operator()(p-q);
    }
} L2Norm;

L2norm(p-q); // Uses the object L2Norm, which has an unnamed type.

How to properly define function objects in c++?

2 Answers2