Effective STL 20 Specify comparison types for associative containers of pointers

define a set

set<string*>ssp;

// is shorthand for this:
set<string*, less<string*> > ssp;

// to be completely accurate, it's shorthand for
set<string*, less<string*>, allocator<string*> > ssp;

I. specify comparison type

// set tmplate's three parameters is a type. it wants a type that can 
// internally instantiate to create a function.
struct StringPtrLess:
    public binary_function<const string*, const string*, bool> {
    bool operator()(const string* *ps1, const string* ps2) const {
        return *ps1 < *ps2;
    }
};

typedef set<string*, StringPtrLess> StringPtrSet;
StringPtrSet ssp;

II. better way to specify comparison

struct DeferenceLess {

    template<typename PtrType>
    bool operator()(PtrType pT1, PtrType pT2) const {
        return *pT1 < *pT2;
    }
};

set<string*, DerefernceLess> ssp;

III. why better?

// explanation (from item 7)
class SpecialString:public string {...};

template<typename T>
struct DeleteObject:
    public unary_function<const T*, void> {
    void operator()(const T* ptr) const {
        delete ptr;
    }
};

deque<SpecialString*> dssp;
...
for_each(dssp.begin(),                   // Error! Deletion of a derived 
    dssp.end(), DeleteObject<string>()); // object via a base class pointer 
                                         // where there is no virtual 
                                         // destructor

// then, move the templatization from DeleteObject to its operator():
struct DeleteObject {
    template<typename T>
    void operator()(const T*ptr) const {
        delete ptr;
    }

deque<SpecialString*> dssp;
...

// Compilers know the type of pointer being passed to DeletObject::operator(), 
// so we have them automatically instantiate an operator() taking that type of pinter
for_each(dssp.begin(), dssp.end(), DeleteObject()); // well!

print directly

for (StringPtrSet::const_iterator i = ssp.begin(); 
    i != ssp.end();
    ++i) {
    cout << *i << endl;

for_each print

void print(const string *ps) {
    cout << *ps << endl;
}
for_each(ssp.begin(), ssp.end(), print);

transform print

// Compilers know the type of pointer being passed to DeletObject::operator(), 
// so we have them automatically instantiate an operator() taking that type of pinter
// when functors of this type are passed a T*, they return a const T&
struct Dereference {
    template<typename T>
    const T& operator()(const T *ptr) const {
        return *ptr;
    }
};
transform(ssp.begin(), ssp.end(), ostream_iterator<stirng>(cout, "\n"), Dereference());