STL nuances - sort and remove_if

Interesting. Make the () operator public.

Kuphryn

Hi Folks,
I am not able to understand as to when must an STL Predicate Function be implemented as a structure and when as a class?In C++, there is no difference between a struct and a class except for

1) the default access specification for the members (struct is public, class it's private)

2) default inheritance access specification (when deriving from a base struct, the base struct is defaulted to public inheritance. When deriving from a base class, the base class is defaulted to private inheritance.

So I don't know why you distinguish between a struct and a class when they are essentially the same thing.
I have a list of int* declared as -
Hopefully that is only for an exercise. There is no reason whatsoever to have a list<int *> when all you need is list<int>.
But, should I want the sort predicate defined as a class inheriting greater <int*> - the sort does not work!You see that both of those examples are different, much more than the difference between "struct" and "class" (as I stated above, there is essentially no difference in C++ between the two).

So, this compiles, but, does not work -
typedef int* PINT;

class IsGreater : public std::greater<PINT>
{
bool operator() (const PINT & lhs, const PINT & rhs) const
{
return (*lhs) > (*rhs);
}
};

1) The operator() is private. How can it be accessed?

2) The equivalent is this using struct:

typedef int* PINT;

struct IsGreater : public std::greater<PINT>
{
private:
bool operator() (const PINT & lhs, const PINT & rhs) const
{
return (*lhs) > (*rhs);
}
};
Regards,

Paul McKenzie

2. Yes, I believe too that there is no difference between class and struct. But, cannot explain the difference in behaviour.Look at the struct and class that I posted, and take a look at the struct and class that you are saying behaves differently. The ones that you posted are different.

template <>
struct std::greater<int*>
//...
typedef int* PINT;
class IsGreater : public std::greater<PINT>
//...
Why do you say these are the same? They are clearly different. The struct and class I posted are exactly the same thing. Therefore if you took my struct, it should also cause an error if the class version causes an error.

So again, the problem is *not* class vs. struct. I will use your "struct" example that works, and use "class".

template <>
class std::greater<int*>
{
public:
bool operator()(const int* lhs, const int* rhs) const
{
return *lhs > *rhs;
}
};

That is equivalent to your struct example, not the class that you posted.

Anyway, wasn't your list::sort on pointers question answered here:

http://www.dev-archive.com/forum/showthread.php?t=330771&highlight=list+sort

?

Regards,

Paul McKenzie

Look at the struct and class that I posted, and take a look at the struct and class that you are saying behaves differently. The ones that you posted are different.

1. My question is not about sorting a list.
2. Yes, this struct and class are different, no doubt. Perhaps, I threw in a Red Herring there.

I need an explanation as to why sort can have a struct/class as a predicate without inheriting, whilst the remove_if needs a class that inherits from std::not_equal_to <int*>

Or to express it differently again - why can the predicate to remove_if not be
struct std::not_equal_to <int*>
{
bool operator () (const PINT & x, const PINT & y) const
{
return (*x) == (*y);
}
};

instead of

class AreNotEqual: public std::not_equal_to <int*>
{
bool operator () (const PINT & x, const PINT & y) const
{
return (*x) == (*y);
}
};