I have a simple problem but I don't know how to solve it because I have never used functors in C++.

I want to do something like that (it is just an example) :

class MyClass
{
    void applyFunction(myFunction);  /* WRONG SYNTAX */
    double *_x;
    unsigned int *_size;
};

void MyClass::applyFunction(myFunction) /* WRONG SYNTAX */
{
    for (unsigned int i = 0; i < _size; ++i)
        myFunction(_x[i], 10.);
}

class OtherClass
{
    void myFunction1(double x, double lim);
    void myFunction2(double x, double lim);
    std::vector _v;
};

void OtherClass::myFunction1(double x, double lim)
{
    _v.clear();
    if (x > lim)
        _v.push_back(x);
}

void OtherClass::myFunction2(double x, double lim)
{
    _v.clear();
    if (x < lim)
        _v.push_back(x);
}

int main()
{
    MyClass myClass;
    OtherClass otherClass;
    myClass.applyFunction(otherClass.myFunction1); /* WRONG SYNTAX */
    std::cout<<otherClass._v.size()<<std::endl;
    myClass.applyFunction(otherClass.myFunction2); /* WRONG SYNTAX */
    std::cout<<otherClass._v.size()<<std::endl;
        return 0;
}

What would be the correct syntax to use functors/std::functions ?

Thank you very much !

• c++
• functor
• std-function

I'll take you at your word that you want to use functors for this. Just for grins, I'll also assume you want to do this the "right" way, not just find a syntax that will let it compile (and probably run, perhaps doing what you wanted).

In this case, the standard library already has algorithms to support much of what you're doing (especially in C++11). To copy the data that meets some criteria into a target vector, you have std::copy_if (though that's missing in C++98/03 -- you have to reverse the sense of the comparison and use std::remove_copy_if).

Using this, your code becomes something like this:

template <class T>
class less_than {
    T limit;
public:
    less_than(T lim) : limit(lim) {}
    bool operator()(T const &val) { return val < limit; }
};

std::copy_if(source.begin(), 
             source.end(), 
             std::back_inserter(target), 
             less_than<int>(10));

However, if you have C++11 available, it's probably more convenient to use a lambda instead:

std::copy_if(source.begin(), 
             source.end(), 
             std::inserter(target), 
             [](int v) { return v < 10;});

The lambda is basically just a way of getting the compiler to generate an anonymous functor class for you, so there's not much real difference between the two, but the lambda obviously saves quite a bit of typing.

If you're stuck with C++03, you basically just invert the comparison:

template <class T>  
class greater_than { 
    T limit;
public:
    bool operator()(T const &val) {
        return val > limit;
    }
};

std::remove_copy_if(src.begin(), 
                    src.end(), 
                    std::back_inserter(dst),
                    greater_than(10));

Alternatively, you could write your own copy_if pretty easily -- it was left out of C++98/03 mostly by oversight, not because it needs anything the language doesn't provide, or anything like that (though as I recall, getting all the border conditions exactly right can be a little tricky).

For what it's worth, I should also note that the standard library does have std::less and std::greater, so the less_than and greater_than functors I've given above aren't really necessary. Unfortunately, they just do the comparison, so to use them as we're doing here, you have to use std::bind1st or std::bind2nd to get them to compare to a constant:

std::remove_copy_if(src.begin(),
                    src.end(),
                    std::ostream_iterator<int>(std::cout, "\n"),
                    std::bind1st(std::less<int>(), 10));

void applyFunction(std::function<void(double, double)>);
// ...
applyFunction(std::bind(&OtherClass::myFunction1, &otherClass));