STL,Template，继承，多态的例子

//使用map结构进行单词的转换，第一个参数为提供转换格式的文件，第二个参数为输入文件
#include <iostream>
#include <map>
#include <fstream>
#include <sstream>
#include <string>
using namespace std;

int main( int argc, char **argv)
{
    map<string,string> trans_map;
    string key, value;
    if( argc != 3)
        throw runtime_error("wrong number of arguments");
    ifstream map_file;
    map_file.open(argv[1]);
    if (!map_file)
        throw runtime_error("no transformation file");
    while ( map_file >> key >> value)
        trans_map.insert(make_pair(key, value));

    ifstream input;
    input.open(argv[2]);
    if( !input)
        throw runtime_error("no input file");
    string line;
    while( getline( input, line))
    {
        istringstream stream(line);
        string word;
        bool firstword  = true;
        while( stream >> word)
        {
            map<string, string>::const_iterator map_it = trans_map.find(word);
            if ( map_it != trans_map.end())
                word  = map_it->second;
            if( firstword)
                firstword = false;
            else
                cout << " ";
            cout << word;
        }
        cout << endl;
    }
    return 0;
}

//容器的综合应用：文本查询程序
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;

class TextQuery
{
public:
    typedef vector<string>::size_type  line_no;
    void read_file( ifstream &is)
    {
        store_file(is);
        build_map();
    }
    set<line_no> run_query(const string&) const;
    string text_line(line_no) const;
    line_no size() const
    {
        return (line_no)lines_of_text.size();
    }
private:
    void store_file( ifstream &);
    void build_map();
    vector<string> lines_of_text;                       //文件中的每一行是该vector对象的一个元素
    map <string, set<line_no> >word_map;      //将单词的行号存入set对象中。使用set可以保证每行只有一个条目，而且自动按升序排列
                                                                      //使用一个map容器将每个单词与一个set容器关联起来，该set对象记录此单词所在行号
};
//存储输入文件
void TextQuery::store_file(ifstream &is)
{
    string textline;
    while( getline(is,textline) )
        lines_of_text.push_back(textline);
}
//建立单词map容器
void TextQuery::build_map()
{
    for (line_no line_num=0; line_num != lines_of_text.size(); ++line_num)
    {
           istringstream line(lines_of_text[line_num]);
        string word;
        while ( line >> word)
            word_map[word].insert(line_num);
    }
}
//支持查询
set<TextQuery::line_no> TextQuery::run_query(const string &query_word) const
{
    map<string, set<line_no> >::const_iterator loc = word_map.find(query_word);
    if ( loc == word_map.end())
        return set<line_no>();
    else
        return loc->second;
}

//run_query 返回值的使用
string TextQuery::text_line(line_no line) const
{
    if( line < lines_of_text.size())
        return lines_of_text[line];
    throw out_of_range("line number out of range");
}

//输出结果
void print_results(const set<TextQuery::line_no> & locs,const string& sought, const TextQuery &file)
{
    typedef set<TextQuery::line_no> line_nums;
    line_nums::size_type size = locs.size();
    cout << "\n" <<sought << " occurs" << size <<" " <<endl;
    line_nums::const_iterator it = locs.begin();
    for ( ; it != locs.end(); ++it)
    {
        cout <<"\t(line"<< (*it)+1<<") " 
            << file.text_line(*it) <<endl;
    }
}

int main( int argc, char **argv)
{
    ifstream infile;
    infile.open(argv[1]);
    if( !infile)
        throw runtime_error("no input file");
    TextQuery tq;
    tq.read_file(infile);
    while(true)
    {
        cout <<"enter word to look for, or q to quit; ";
        string s;
        cin >> s;
        if ( !cin || s == "q") 
            break;
        set<TextQuery::line_no> locs = tq.run_query(s);
        print_results(locs,s,tq);
    }
    return 0;
}

//文本查询面向对象的实现，可支持与，或，非查询，使用的是继承和动态绑定
//查询类的抽象基类
class Query_base
{
    friend class Query;                                                            // 友元类，可以访问Query_base成员函数和变量
protected:
    typedef TextQuery::line_no line_no;
    virtual ~Query_base() { }                                                      //虚析构函数
private:
    virtual set<line_no> eval(const TextQuery&) const =0;        //纯虚函数，每个派生类都有自己的实现
    virtual ostream& display( ostream & = cout) const =0;
};

//用户计数的句柄类，它指向Query_base派生类的对象
class Query{
    friend Query operator ~(const Query &);                                //友元函数重载运算符
    friend Query operator | (const Query &, const Query &);
    friend Query operator & (const Query &, const Query &);
    friend ostream & operator <<(ostream &os,const Query &q)
    {
        return q.display(os);
    }
public:
    Query( const string&);
    Query(const Query &c): q(c.q), use(c.use)
    { ++*use;}
    ~Query() { decr_use(); }
    Query & operator =(const Query &);
    set<TextQuery::line_no> eval(const TextQuery &t) const 
    {
        return q->eval(t);
    }
    ostream &display( ostream &os) const
    {
        return q->display(os);
    }
private:
    Query(Query_base * query): q(query), use(new size_t(1))
    { }
    Query_base *q;                                                                            //基类指针，可以指向派生类对象，从而实现多态
    size_t *use;
    void decr_use()
    {
        if( --*use == 0) 
        { 
            delete q; 
            delete use;
        }
    }
};

inline Query operator & (const Query &lhs, const Query &rhs)
{
    return new AndQuery(lhs, rhs);
}
inline Query operator | (const Query &lhs, const Query &rhs)
{
    return new OrQuery(lhs,rhs);
}
inline Query operator ~(const Query &oper)
{
    return new NotQuery(oper);
}


class WordQuery: public Query_base
{
    friend class Query;
    WordQuery(const string &s):query_word(s){ }
    set<line_no> eval(const TextQuery &t ) const 
    {
        return t.run_query(query_word);
    }
    ostream& display( ostream &os ) const 
    {
        return os << query_word;
    }
    string query_word;
};


class NotQuery: public Query_base
{
    friend Query operator ~ (const Query &);
    NotQuery(Query q): query(q) { }
    set<line_no> eval( const TextQuery &) const;
    ostream & display(ostream &os) const
    {
        return os << "~(" <<  query << ")";
    }
    const Query query;
};

set<TextQuery::line_no> NotQuery::eval(const TextQuery & file) const
{
    set<line_no> has_val = query.eval(file);
    set<line_no> ret_lines;
    for ( line_no n=0; n != file.size();  ++n)
        if( has_val.find(n) == has_val.end() )
            ret_lines.insert(n);
    return ret_lines;
}

class BinaryQuery: public Query_base
{
protected:
    BinaryQuery(Query left, Query right, string op) : lhs(left), rhs(right), oper(op)
    { }
    ostream& display( ostream &os) const
    {
        return os << "(" << lhs << " " << oper << " "
            <<rhs << ")";
    }
    const Query lhs, rhs;
    const string oper;
};

class AndQuery: public BinaryQuery
{
    friend Query operator& (const Query&,const Query&);
    AndQuery(Query left, Query right) : BinaryQuery(left,right,"&") { }
    set<line_no> eval(const TextQuery &) const;
};

set<TextQuery::line_no> AndQuery::eval(const TextQuery & file) const
{
    set<line_no> left = lhs.eval(file), right = rhs.eval(file);
    set<line_no> ret_lines;
    set_intersection(left.begin(), left.end(),
                            right.begin(), right.end(), 
                            inserter(ret_lines, ret_lines.begin() ));
    return ret_lines;
}

class OrQuery : public BinaryQuery
{
    friend Query operator|(const Query&, const Query&);
    OrQuery(Query left,Query right) : BinaryQuery(left,right,"|") { }
    set<line_no> eval(const TextQuery &) const;
};

set<TextQuery::line_no> OrQuery::eval( const TextQuery &file) const
{
    set<line_no> right = rhs.eval(file),
        ret_lines = lhs.eval(file);
    ret_lines.insert(right.begin(), right.end() );
    return ret_lines;
}


//完整的模版Queue类
template< class Type> class Queue;
template <class T> ostream& operator << ( ostream &, const Queue<T>&);
template <class Type>
//队列中元素
class QueueItem{
public:
    friend class Queue<Type>;                                                        //声明为友元类
    friend ostream & operator << <Type> ( ostream&, const Queue<Type>&);
    QueueITem(const Type &t) : item(t), next(0) { }
    Type item;
    QueueItem *next;
};

//支持具体操作的队列类
template<class Type> 
class Queue
{
    friend ostream & operator << <Type> (ostream &, const Queue<Type> &);
public:
    Queue( ): head(0),tail(0) { }
    template<class It>
    Queue(It beg, It end): head(0), tail(0) { copy_elems(beg,end); }
    Queue(const Queue &Q) : head(0), tail(0) { copy_elems(Q); }
    Queue& operator = (const Queue&);
    ~Queue( ) { destroy( ); }
    template<class Iter> void assign(Iter, Iter);
    Type & front( ) { return head->item; }
    const Type &front() const { return head->item; }
    void push(const Type &);
    void pop( );
    bool empty( ) const {
        return head == 0;
    }
private:
    QueueItem<Type> *head;
    QueueItem<Type> *tail;
    void destroy();
    void copy_elems(const Queue&);
    template <class Iter> void copy_elems(Iter, Iter);
};

template <class Type> 
void Queue<Type>::destroy()
{
    while ( !empty() )
        pop();
}

template<class Type>
void Queue<Type>::pop()
{
    QueueItem<Type> *p = head;
    head = head->next;
    delete p;
}

template<class Type>
void Queue<Type>::push( const Type &val)
{
    QueueItem<Type> *pt = new QueueItem<Type>(val);
    if(empty())
        head = tail = pt;
    else
    {
        tail ->next = pt;
        tail = pt;
    }
}

template<class Type>
void Queue<Type>::copy_elems( const Queue &orig)
{
    for ( QueueItem<Type> *pt = orig.head; pt; pt = pt->next)
        push( pt->item);
}



//定义泛型句柄类
template <class T> 
class Handle
{
public:
    Handle(T *p=0) : ptr(p), use(new size_t(1) ) { }                //构造函数
    T & operator *();                                                            //重载运算符
    T * operator ->();
    const T& operator *() const;
    Handle( const Handle & h) : ptr(h.ptr), use(h.use)            //复制构造函数
    { ++*use;}
    Handle & operator = (const Handle&);                            //赋值函数
    ~Handle() { rem_ref(); }
private:
    T* ptr;                                                                            //原始指针
    size_t *use;                                                                    //使用次数
    void rem_ref()                                                                //删除操作
    {
        if( --*use ==0)
        {
            delete ptr; 
            delete use;
        }
    }
};

template <class T>
inline Handle<T> & Handle<T>::operator=( const Handle &rhs)
{
    ++*rhs.use;
    rem_ref();
    ptr = rhs.ptr;
    use = rhs.use;
    return *this;
}

template<class T>
inline T& Handle<T>::operator*()
{
    if ( ptr) return *ptr;
    throw runtime_error("dereference of unbound Handle");
}

template<class T>
inline T* Handle<T>::operator->()
{
    if( ptr ) return ptr;
    throw runtime_error("access through unbound handle");
}