《C++标准程序库》笔记之二

std::set<float> c1;     // sorting criterion -> std::less<>
std::set<float, std::greater<float> > c2;     // sorting criterion -> std::less<>
...
if (c1 == c2)          // ERROR:different types
{
    ...
}

#include <iostream>
#include <string>
#include <set>
#include <algorithm>
using namespace std;

class Person
{
    public:
        string firstname() const;
        string lastname() const;
        ....
};
/* class for function predicate
* - operator() returns whether a person is less than another person
*/
class PersonSortCriterion
{
    public:
        bool operator() (const Person& p1, const Person& P2) const
        {    
            /* a person is less than another person
            * - if the last name is less
            * - if the last name is equal and the first name is less
            */
            return p1.lastname() < p1.lastname() ||
                (!(p2.lastname() < p1.lastname()) &&
                p1.firstname() < p2.firstname());
        }
};

int main()
{
    // declare set type with special sorting criterion
    typedef set<Person, PersonSortCriterion> PersonSet;

    // create such a collection
    PersonSet coll;
    ...

    // do something with the elements
    PersonSet::iterator pos;
    for(pos = coll.begin(); pos != coll.end(); ++pos)
    {
        ...
    }
    ...
}

// 执行期指定排序准则，排序准则不同，但型别相同：
#include <iostream>
#include <set>
using namespace std;

// type for sorting criterion
template <class T>
class RuntimeCmp
{
    public:
        enum cmp_mode {normal, reverse};
    private:
        cmp_mode mode;
    public:
        // constructor for sorting criterion
        // - default criterion uses value normal
        RuntimeCmp(cmp_mode m = normal) : mode(m) { }

        // comparision of elements
        bool operator() (const T& t1, const T& t2) const
        {
            return mode == normal ? t1 < t2 : t2 < t1;
        }

        // comparision of sorting criteria
        bool operator== (const RuntimeCmp& rc)
        {
            return mode == rc.mode;
        }
};

// type of a set that uses this sorting criterion
typedef set<int, RuntimeCmp<int> > IntSet;

// forward declaration
void fill(IntSet& set);

int main()
{
    // create, fill, and print set with normal element order
    // - uses default sorting criterion
    IntSet coll1;
    fill(coll1);
    print_elements(coll1, "coll1 :");

    // create sorting criterion with reverse element order
    RuntimeCmp<int> reverse_order(RuntimeCmp<int>::reverse);

    // create, fill, and print set with reverse element order
    IntSet coll2(reverse_order);
    fill(coll2);
    print_elements(coll2, "coll2 :");
    
    // assign elements AND sorting criterion
    coll1 = coll2;
    coll1.insert(3);
    print_elements(coll1, "coll1 :");
    
    // just to make sure...
    if(coll1.value_comp() == coll2.value_comp())
    {
        cout << "coll1 and coll2 have same sorting criterion" << endl;
    }
    else
    {
        cout << "coll1 and coll2 have different sorting criterion" << endl;
    }
}

void fill(IntSet& set)
{
    // fill insert elements in random order
    set.insert(4);
    set.insert(7);
    set.insert(5);
    set.insert(1);
    set.insert(6);
    set.insert(2);
    set.insert(5);
}

输出：
coll1：1 2 4 5 6 7
coll2：7 6 5 4 2 1
coll1：7 6 5 4 3 2 1 
coll1 and coll2 have same sorting criterion

if (!(elem1 < elem2 || elem2 < elem1))