Operator< overloading

[Bas Nedermeijer]

Hello,

i am having trouble to use the sort() function of a list<>.

I cannot seem to overload the operator<().
The variables to compare are references, like

Item* itemA;
Item* itemB;

when comparing "itemA < itemB" my overloaded function isnt called. When
the variables are defined;

Item itemA;
Item itemB;

the overloaded function is called.

I hope it is possible for what i want.


Below is my "operator<", also a "const diritem& rhs" didnt resolve my
problem.
int diritem:perator<(const diritem* rhs) const {

printf("%s < %s\n",this->_filename.c_str(), rhs->_filename.c_str());

if ((this->_type==DT_DIR) && (rhs->_type!=DT_DIR)) {
return 1;
}
if ((this->_type!=DT_DIR) && (rhs->_type==DT_DIR)) {
return 0;
}

return (this->_filename < rhs->_filename);

}

Any pointers are welcome!

Kind regards,
Bas Nedermeijer

 

[tolgaceylanus]

If you make the operator argument "const &" again, you should be
able to call the operator with;

*ptr < *ptr

in case of pointers.

Hope this helps.

Tolga Ceylan

 

[Bas Nedermeijer]

If you make the operator argument "const &" again, you should be
able to call the operator with;

*ptr < *ptr

in case of pointers.

I cannot change the sorting routine, because i want to make use of the
built-in sorting routing of list<>.

But thanks for the reply,

Kind regards,
Bas Nedermeijer

 

[Pierre Barbier de Reuille]

Bas Nedermeijer a écrit :

I cannot change the sorting routine, because i want to make use of the
built-in sorting routing of list<>.

But thanks for the reply,

Kind regards,
Bas Nedermeijer

Hi ! Your problem is that you cannot overload the < operator for
pointers, as it already exists (it compare the actual address of the
pointers). You need either to create a list of objects (and not
pointers), or to use smart pointers. In the case of smart pointers, you
will be able to redefine the < operator for them. However, why do you
use lists of pointers ? This is very dangerous as the list will never
take care of freeing memory before removing elements.

Pierre

 

[Alan Johnson]

Hello,

i am having trouble to use the sort() function of a list<>.

I cannot seem to overload the operator<().
The variables to compare are references, like

Item* itemA;
Item* itemB;

when comparing "itemA < itemB" my overloaded function isnt called. When
the variables are defined;

Item itemA;
Item itemB;

the overloaded function is called.

I hope it is possible for what i want.


Below is my "operator<", also a "const diritem& rhs" didnt resolve my
problem.
int diritem:perator<(const diritem* rhs) const {

printf("%s < %s\n",this->_filename.c_str(), rhs->_filename.c_str());

if ((this->_type==DT_DIR) && (rhs->_type!=DT_DIR)) {
return 1;
}
if ((this->_type!=DT_DIR) && (rhs->_type==DT_DIR)) {
return 0;
}

return (this->_filename < rhs->_filename);

}

Any pointers are welcome!

Kind regards,
Bas Nedermeijer

The list container has a sort member template that takes a binary
predicate to use for sorting. What you need to do is pass in a
predicate that sorts the objects based on pointers to those objects.
The following template may help:

template <typename T>
struct ptr_less
{
bool operator()(T * p1, T * p2)
{
return *p1 < *p2 ;
}
} ;


And, for what it is worth, here is the program I used to test that
template:

template <typename T>
struct ptr_less
{
bool operator()(T * p1, T * p2)
{
return *p1 < *p2 ;
}
} ;

#include <list>
#include <iostream>
#include <algorithm>

void ptr_out(int * p)
{
std::cout << *p << ' ' ;
}

int main()
{
int a[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 } ;

// Add pointers to the list.
std::list<int *> v ;
for (std::size_t i = 0; i < sizeof(a)/sizeof(a[0]); ++i)
v.push_back(a+i) ;

// Show the list unsorted.
std::for_each(v.begin(), v.end(), ptr_out) ;
std::cout << std::endl ;

// Sort the list.
v.sort(ptr_less<int>()) ;

// Show the list sorted.
std::for_each(v.begin(), v.end(), ptr_out) ;
std::cout << std::endl ;
}

 

[Howard]

However, why do you use lists of pointers ? This is very dangerous as the
list will never take care of freeing memory before removing elements.

I can't answer for the OP, but a quite common reason to store pointers is
when you want polymorphism. Storing base class pointers allows you to store
descendant types in the container.

-Howard

 

[Kai-Uwe Bux]

I cannot change the sorting routine, because i want to make use of the
built-in sorting routing of list<>.

No problem: just define a custom comparison function

bool compare_item_ptr ( item*, item* ) {
// whatever
}

and do

list<item*> l;

...

l.sort( compare_item_ptr );


Best

Kai-Uwe Bux

 

[Bas Nedermeijer]

Bas Nedermeijer wrote:

The list container has a sort member template that takes a binary
predicate to use for sorting. What you need to do is pass in a
predicate that sorts the objects based on pointers to those objects.
The following template may help:

<snip>

Thanks for your solution, it works!

- Bas Nedermeijer