chapter4-23.cpp

C++STL程序员开发指南

//文件名：CHAPTER4-23.cpp
#include "stl.h"
#include <string.h>
#include <iostream>
#include <list>
using namespace std;
class Base 
{public:
    const char* type_name() const { return typename_; }
    virtual Base* clone() const = 0;
    virtual void identify(ostream& os) const = 0;
    virtual ~Base();
public:
    static int count;
protected:
    Base(const char* type_name);
    Base(const Base& base);
private:
    char* typename_;
};
Base::Base(const char* type_name) 
{   const char* tname = (type_name) ? type_name : "unknown";
    strcpy(typename_ = new char[strlen(tname) + 1], tname);
    ++count;
}
Base::Base(const Base& base) {
 strcpy( typename_ = new char[strlen(base.typename_) + 1], base.typename_ );
    ++count;
}
Base::~Base() {  delete[] typename_;   --count; }
class Derived1 : public Base {
public:
    Derived1(int data) : Base("derived1"), data_(data) { }
    Derived1(const Derived1& d) : Base("derived1"), data_(d.data()) { }
    virtual ~Derived1()        { }
    virtual Base* clone() const { return new Derived1(*this); }
    virtual void identify(ostream& os) const;
    int data() const { return data_; }
private:
    int data_;
};
void Derived1::identify(ostream& os) const 
{    os << "(" << type_name() << " " << data() << ")";  }
class Derived2 : public Base {
public:
    Derived2(int data) : Base("derived2"), data_(data) { }
    Derived2(const Derived2& d) : Base("derived2"), data_(d.data()) { }
    virtual ~Derived2()        { }
    virtual Base* clone() const { return new Derived2(*this); }
    virtual void identify(ostream& os) const;
    int data() const { return data_; }
private:
    int data_;
};
void Derived2::identify(ostream& os) const 
{    os << "(" << type_name() << " " << data() << ")"; }
template <class T>
class PtrWrapper {
public:
    PtrWrapper(T* t_ptr = 0) : t_ptr_(t_ptr) { }
    PtrWrapper(const PtrWrapper<T>& w) {
        t_ptr_ = w() ? w()->clone() : 0;
    }
    ~PtrWrapper() { delete t_ptr_; }
    const T* operator()()  const { return t_ptr_; }
    T* operator()()  { return t_ptr_; }
    PtrWrapper<T>& operator= (const PtrWrapper<T>& w) { delete t_ptr_; t_ptr_ = w()->clone();
return *this; }
private:
    T* t_ptr_;
};
template <class T>
bool operator== (const PtrWrapper<T>& w1, const PtrWrapper<T>& w2) { return false; }
template <class T>
bool operator< (const PtrWrapper<T>& w1, const PtrWrapper<T>& w2) {  return false; }
int Base::count = 0;
int main(int, char*[]) 
{
    list<PtrWrapper<Base> > list1;
    list1.push_back(PtrWrapper<Base> (new Derived1(101)));
    list1.push_back(PtrWrapper<Base> (new Derived2(201)));
    list1.push_back(PtrWrapper<Base> (new Derived2(202)));
    list1.push_back(PtrWrapper<Base> (new Derived1(102)));
    list1.push_back(PtrWrapper<Base> (new Derived2(203)));
    list<PtrWrapper<Base> >::const_iterator it = list1.begin();
    for(; it != list1.end(); ++it) { const PtrWrapper<Base>& w = *it; w()->identify(cerr); cerr << " "; }
    cerr << endl << endl;
    return 0;
}