std::list<*> sorting

please could some one explain to me how i implement sorting code for the following:

#include <iostream>
#include <list>

void main(void)
{
list<int *> intPtrList;
int a = 3, b = 7, c = 5;

intPtrList.push_back(&a);
intPtrList.push_back(&b);
intPtrList.push_back(&c);

intPtrList.sort(); // doesnt work (it will sort the pointers)
}

as you see in the code intPtrList.sort() wount work,
but list has an overloded version of sort that takes an parameter
but i dont under stand how to use it. so could some one tell me what that parameter should me to allow me to sort the data correct...

\\dummy

One solution is a predicate.

Code:

---

// Predicate dereferences the elements and compare them.
std::sort(list.begin(), list.end, Predicate);

// Ttry this solution.  I am not completely sure it works as it is a
// feature of the STL.

std::sort(listl.begin(), list.end, std::greater<int *>());

---

One solution for a predicate is a function object.

Kuphryn

sorry, your solutions didnt work =(
they didnt even compile =(

.ziruz

What is the error message?

Add #include <algorithm>

Here's the solution

Code:

---

bool myCompare(int* a, int* b)
{
    return *a < *b;
}


int main()
{
  //...
  myIntList.sort(myCompare);
  //...
}

---

Or perhaps more general:

Code:

---

template<typename T>
class myPtrCompare
{
    public:
    bool operator ()(T* a, T* b)
    {
        return *a < *b;
    }
};

int main()
{
  //...
  myIntList.sort(myPtrCompare<int>());
  //...
}

---

wrong thread

Probably need to include <functional> in there to for kuphryn's (for greate<T>).

You're using new-style headers, but you forgot about namespaces.

>>void main(void)
No. Bad. Very bad. Use int main( void ).

Quote:

---

Originally posted by Sang-drax
Here's the solution

Code:

---

bool myCompare(int* a, int* b)
{
    return *a < *b;
}


int main()
{
  //...
  myIntList.sort(myCompare);
  //...
}

---

---

That won't work without ptr_fun() around it; myCompare is not a functor here.

The other code works much better, but a few changes to make it const-correct (you can get a lot of bizarre error messages if it's not):

Code:

---

template<typename T>
class myPtrCompare
{
    public:
    bool operator ()(const T* a, const T* b) const
    {
        return *a < *b;
    }
};

int main()
{
  //...
  myIntList.sort(myPtrCompare<int>());
  //...
}

---

Quote:

---

Originally posted by Cat
That won't work without ptr_fun() around it; myCompare is not a functor here.

---

No it is correct (try it).
You only need to 'wrap' the pointer in ptr_fun,if you need binder (bind2nd for example).

sorting a list is also painfully slow, If I may suggest vector and std::sort(begin,end,cmp) or a sorted container like set/multiset.

Quote:

---

Originally posted by grib
sorting a list is also painfully slow,

---

Why?
Both sorts (list.sort and sort) run in O(n*log(n)).
list.sort is a mergesort,and sort is introsort.

Hmm... Maybe I am remembering incorrectly here, but doesn't the sort function not work on pointers?

I was required to write 5 or 6 sort algorithms and we had to re-write the swap function (part of the sort function) to work with pointers.

Of course, that was a while ago...

>> Hmm... Maybe I am remembering incorrectly here, but doesn't the sort function not work on pointers?

It will work. If you are using pointers though, the default behavior of the sorting algorithms will be to compare the pointers (i.e. the memory addresses), and sort those, rather than sorting the data by value.

>>you can get a lot of bizarre error messages if it's not

I ran into some of those last week... They drove me insane for about half an hour.

>>No it is correct (try it).

Probably a default template argument.

Quote:

---

It will work. If you are using pointers though, the default behavior of the sorting algorithms will be to compare the pointers (i.e. the memory addresses), and sort those, rather than sorting the data by value.

---

Exactly. how does one fix that? Like I mentioned, we rewrote the swap function, but we also had to change the operator<

- SB

>> Exactly. how does one fix that? Like I mentioned, we rewrote the swap function, but we also had to change the operator<

Yep, thats the way to do it.

>> we rewrote the swap function
How?
Try iter_swap

Code:

---

template<class _FwdIt1,
        class _FwdIt2> inline
        void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)
        {        // swap *_Left and *_Right
        std::swap(*_Left, *_Right);
        }

---

Quote:

---

Originally posted by Cat
That won't work without ptr_fun() around it; myCompare is not a functor here.

The other code works much better, but a few changes to make it const-correct (you can get a lot of bizarre error messages if it's not):
[/code]

---

You don't have to add the const modifiers, the template takes care of that for you.

>>> You don't have to add the const modifiers, the template takes care of that for you.

Not necessarily. GCC gave me errors for not having the last const when I used that last week.