Sorting list of shared pointers

I need to sort a list of std::shared_ptr based on criteria defined via an overloaded operator < in the struct I'm storing via the smart pointers.
Naturally, the std::shared_ptr define operator < as

Code:

---

template<class _Ty1,
        class _Ty2>
        bool operator<(const shared_ptr<_Ty1>& _S1,
                const shared_ptr<_Ty2>& _S2)
        {        // test if shared_ptr < shared_ptr
        return (_S1.get() < _S2.get());
        }

---

That is, comparison of the pointers, while boost's smart pointer defines the operator via a comparison of the pointees.

So say I have

Code:

---

std::list<std::shared_ptr<my_t>> list;
// Add stuff to list
list.sort();

---

What would be a good approach to sort the list using the operator < defined in my_t?

You can pass a strict weak ordering predicate to list::sort:

Code:

---

bool myt_lt (const std::shared_ptr<my_t>& left,
  const std::shared_ptr<my_t>& right)
{
  return (*left.get() < *right.get());
}

...
std::list<std::shared_ptr<my_t> > list;
...
list.sort(myt_sort);

---

This doesn't work generically, though, if I have a parameter type T.

Code:

---

template<typename T> void mfunc()
{
    std::list<std::shared_ptr<T>> list;
    // Add stuff to list
    list.sort();
}

---

So, make the predicate a template:

Code:

---

template<class T>
bool shared_ptr_lt (const std::shared_ptr<T>& left,
  const std::shared_ptr<T>& right)
{
    return (*left.get() < *right.get());
}

template<class T>
void func()
{
  std::list<std::shared_ptr<T> > list;
  //...
  list.sort(shared_ptr_lt<T>);
}

---

Ah, I missed that predicate part. I wasn't aware sort had an overload that takes a predicate function to sort.
Thanks. That's what I need.

Does Ronix's example even compile? I believe that you have to use a class template rather than a function template, and then pass an object of that class template to the sort member function.

EDIT:
Ooh, it does work.

Compiles for me on g++ 4.4.1, although I used std::auto_ptr because I don't know the correct header for std::shared_ptr.

It should be in <memory>. But it also requires C++0x enabled.

You could use std::tr1::shared_ptr if std::shared_ptr is not available.

If we're talking about C++0x you could take Ronix's example a step further and use a lambda for the predicate parameter to sort:

Code:

---

template<typename T>
void mfunc()
{
    std::list<std::shared_ptr<T>> list;
    // Add stuff to list
    list.sort([](const std::shared_ptr<T> & lhs, const std::shared_ptr<T> & rhs)
    {
        return (*lhs.get() < *rhs.get());
    });
}

---

I would rather have a functor or free function to do this, though, since it avoids code duplication and is shorter.
Though that works, I think I would it for special occasions.