predicate function

[ChayKieu]

I bet there should be times you need to use a predicate not only with 2 parameters but more than that. I am now wondering how can I pass in an algorithm's function a predicate with 3 or more parameters.

That's the point where my knowledge about STL stops, could someone clear it up with new roads from here ?

Thank you.

[Chris_F]

Why don't you try posting an example of the situation you are talking about.

[Eri523]

I'm not really certain about your scenario either, but it looks like what you want is a functor instead of a function as the predicate. Its operator() would then take the usual parameters passed to the predicate by the STL algorithm, and any other information your functor object needs can be set up any way you want before invoking the algorithm.

[Lindley]

I don't think any of the existing STL algorithms require a predicate with more than 2 arguments.

[ChayKieu]

Thanks I always meet problems with more than 2

For example,

bool pred(T a, T b, bool c)
{
return c?a.x<b.y:a.x>b.y;
}

this is not allowed is , e.g remove_if

[Lindley]

struct CompareDim
{
    bool cmpX;
    CompareDim(bool compareX)
        :cmpX(compareX)
    {}
    bool operator()(T a, T b) const
    {
           return cmpX ? a.x<b.y : a.x>b.y;
    }
};

int main()
{
    vector<T> myvec;
    .....
    myvec.erase(
        remove_if(myvec.begin(),myvec.end(),CompareDim(true)),
        myvec.end());
}

Or, in C++0x lambda functions....

int main()
{
    vector<T> myvec;
    .....
    bool cmpX = true;
    myvec.erase(
        remove_if(myvec.begin(),myvec.end(),[cmpX](T a, T b){ return cmpX ? a.x<b.y : a.x>b.y; }),
        myvec.end());
}

[Eri523]

Lindley, under which circumstances does remove_if() take a binary predicate?

I had my proposed code sample just ready when the notification mail about your post came in, and now that I have it I want to post it... It is a functor-style unary predicate that takes the "other" T and the bool as constructor parameters:

class predicate
{
public:
  predicate(const T &b, bool c) : m_b(b), m_c(c)
  {}

  bool operator()(const T &a) const
  {
    return m_c ? a.x < m_b.y : a.x > m_b.y;
  }

private:
  const T &m_b;
  bool m_c;
};

BTW, how does your first example work at all, as I don't see an operator() in there anywhere? Is there a third way to define predicates I don't know of yet?

Actually, I, personally, find the lambda function example even easier to understand. I'm gradually approaching comprehension of them...

[Lindley]

Lindley, under which circumstances does remove_if() take a binary predicate?
...
BTW, how does your first example work at all, as I don't see an operator() in there anywhere? Is there a third way to define predicates I don't know of yet?

You're right, I goofed on the operator. And remove_if is not a good example of this predicate (perhaps std::sort would be better).

[Eri523]

You're right, I goofed on the operator.

Ah, ok.

And remove_if is not a good example of this predicate (perhaps std::sort would be better).

Indeed, for std::sort() a binary predicate makes perfect sense. I'm not familiar enough with the STL algorithms to reliably tell off the top of my head which of them require a binary predicate and which a unary one (given it requires a predicate at all).

I'm curious about what would happen when remove_if() actually would get presented a binary predicate. I somehow suppose it would throw some sort of "operator not defined" error during template instantiation, right?

Of course it would be no problem to define a functor which is both a unary and a binary predicate at the same time. This would provide allround compatibility though I have only a vague idea of what that might be useful for. (However, I don't have the slightest idea of which practical use the predicate skeleton presented by the OP in post #5 might be either.)

While it's clearly not possible to simply take the address of an overloaded function due to overload resolution ambiguity, it might be even possible to use overloaded unary and binary function-style predicates of the same name for the STL algorithms due to the way template instantiation works (at compile-time!). However, this is just wild speculation and I can't imagine any practical use for that either.

[laserlight]

it might be even possible to use overloaded unary and binary function-style predicates of the same name for the STL algorithms due to the way template instantiation works (at compile-time!). However, this is just wild speculation and I can't imagine any practical use for that either.

Maybe such a dual purpose predicate can be used with std::transform

Incidentally, by "function-style predicates" I think you mean "function object predicates".

[Eri523]

Maybe such a dual purpose predicate can be used with std::transform

Ah! I was looking for an example of this and std::transform() definitely is one. Thanks.

Incidentally, by "function-style predicates" I think you mean "function object predicates".

Err... Unless I misunderstand you here: no. To those you mean I was referring as "functor-style". Maybe I should brush up my terminology regarding this area of C++ a bit?

[laserlight]

Err... Unless I misunderstand you here: no. To those you mean I was referring as "functor-style". Maybe I should brush up my terminology regarding this area of C++ a bit?

Yes, because in C++ terminology, function object and functor are synonymous

[Eri523]

Yes, because in C++ terminology, function object and functor are synonymous

Well, that's why I used the term "fuction-style" as opposed to "functor-style". I never wrote "function-object-style" as a third variant which of course woud've pretty much messed up the whole thing.