STL list.sort() question

if you have a hypothetical class like:

Code:

---

class myClass{

    public:

    private:

        int n;
        string m_string;
        char m_char;
        // etc.
};

---

is there a way to use the STL list.sort() function to sort with respect to one of your private members? in this case i'd like to sort with respect to the integer "n".
?????????

Yes... you'd have to create an appropriate comparison function object and pass that to the sort function or overload the less-than operator for the class.

oh great, it can be done.

how might the overloaded operator look?

Quote:

---

how might the overloaded operator look?

---

It would be a free function with the prototype:

Code:

---

bool operator<(const myClass& lhs, const myClass& rhs);

---

If you do not provide an accessor for n, then it should be a friend function of myClass.

Here's one way (using a non-member, non-friend function):

Code:

---

bool operator<( const myClass& lhs, const myClass& rhs )
{
    return (lhs.GetN() < rhs.GetN());
}

---

This assumes that you have a public member function in myClass that returns the value of n.

thank you all!

you guys are very helpful.

hmmmm.

my compiler is telling me that the operator< must take exactly on argument.
here's the errors I'm getting:

Code:

---

operator1.cpp:15: error: ‘bool testObj::operator<(const testObj&, const testObj&)’ must take exactly one argument
operator1.cpp: In member function ‘bool testObj::operator<(const testObj&, const testObj&)’:
operator1.cpp:17: error: no matching function for call to ‘testObj::get_n() const’
operator1.cpp:13: note: candidates are: int testObj::get_n() <near match>
operator1.cpp:17: error: no matching function for call to ‘testObj::get_n() const’
operator1.cpp:13: note: candidates are: int testObj::get_n() <near match>
make: *** [operator1.o] Error 1

---

here's the class that I'm compiling:

Code:

---

class testObj{
       
        public:
       
                testObj(int x) : n(x) {};
       
                void set_n(int x){ n = x; };
                int get_n(){ return n; };
               
                bool operator<(const testObj& lhs, const testObj& rhs){
                       
                        return (lhs.get_n() < rhs.get_n());
                }
               
        private:
       
                int n;
};

---

You EITHER have one object as input to operator< and declare it as a class member function, or you declare it OUTSIDE of the class, with two parameters.

--
Mats

okay. i think i got sort to work like i wanted to, but i have no way of seeing the effect.

i'd like to have a fucntion like:

Code:

---

void show_list(list<testObj>& mlist){

    for(list<testObj>::iterator i = mlist.begin(); i != mlist.end(); i++){

        cout << *i << endl;
    }
}

---

that would behave the same way if i had a simple list of integers.

I'm guessing i would need to overload the operator*() but i'm not sure how.

If i created my own template, my iterator class would have its own pointer so that it could be overloaded like:

Code:

---

const T& operator*() const { return curr->data; };

T& operator*() { return curr->data; };

---

but of course i'm using the STL so that won't work. any ideas?

You would actually need to overload the operator<< for your class. The operator* is already overloaded for the iterator to return a reference to the object in the list, so that's why you don't have to worry about that.

The operator<< is a non-member function with this signature:

Code:

---

std::ostream& operator<<(std::ostream& out, const testObj& obj);

---

Again, it may need to be a friend if it accesses internal data in the class.

Unlike the operator< there is no member function version that will work, it has to be a non-member (free) function.

You want it to be like this:

Code:

---

                friend bool operator<(const testObj& lhs, const testObj& rhs){
                       
                        return (lhs.n < rhs.n);
                }
};

---

show_list can be written like this to show that it is sorted:

Code:

---

void show_list(const list<testObj>& mlist){

    for(list<testObj>::const_iterator i = mlist.begin(); i != mlist.end(); ++i){
        cout << i->get_n() << endl;
    }
}

---

Following the trend, it should be really easy to devise a STL solution if you're going to be writing stream inserters anyway. For example:

Code:

---

#include <algorithm>
#include <iostream>
#include <ostream>

template<class someType> struct display
{
    void operator() (const someType & that) const
    {
        std::cout<<that<<std::endl;
    }
};

int main()
{
    typedef /**myType**/ yourType;
    typedef std::list<yourType> yourContainer;

    yourType it;
    yourContainer foo;

    for( int items = 0; items < 10; ++items ) {
        std::cin>>it;
        foo.push_back( it );
    }
    std::for_each( foo.begin(), foo.end(), display<yourType>() );
}

---

But you can do that without the helper if your operator<< is defined:

Code:

---

std::copy(foo.begin(), foo.end(), std::ostream_iterator<yourType>(std::cout, "\n"));

---

cool. everythings working beautifully now.

i learned a lot in this discussion!

thank you all!