关于一个inline用法的有关问题,请进来看看

#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <set>
using std::cin;using std::cout;using std::endl;
using std::string;using std::vector;
using std::ostream;using std::fstream;using std::stringstream;
using std::set;using std::multimap;using std::pair;
using std::runtime_error;

class TextQuery{
public:
    typedef multimap<string,int>::const_iterator multi_con_iter;
     typedef pair<TextQuery::multi_con_iter,TextQuery::multi_con_iter> multi_word_range;
    bool Is_file_ok;
    void Text_file_set(const string& file_path);
    pair<multi_con_iter,multi_con_iter> RUN_QW(string Query_word);
    void QueryPrint();
private:
    pair<multi_con_iter,multi_con_iter> Query_word_range;

    multimap<string,int> Word_line;
    set<int> Get_text_line;
    vector<string> Text_file;
    int Occurs_time;
};

void TextQuery::Text_file_set(const string& file_path){
    fstream open_text_file;
    open_text_file.open(file_path.c_str(),fstream::in);
    if(!open_text_file) {Is_file_ok=false;}
    else{
        string tempsentence;
        Text_file.clear();
        while(getline(open_text_file,tempsentence)) Text_file.push_back(tempsentence);
        open_text_file.close();
        open_text_file.clear();

        int line=1;
        Word_line.clear();
        stringstream get_each_word_line;
        for(vector<string>::const_iterator iter=Text_file.begin();iter!=Text_file.end();iter++,line++){
            get_each_word_line.str(*iter);
            while(get_each_word_line>>tempsentence){
                Word_line.insert(make_pair(tempsentence,line));
            }get_each_word_line.clear();
        }    
        Is_file_ok=true;
    }
}

TextQuery::multi_word_range TextQuery::RUN_QW(string Query_word){
    if(!Is_file_ok) throw runtime_error("Could NOT OPEN THE FILE!");
    Get_text_line.clear();
    Occurs_time=0;
    Query_word_range=Word_line.equal_range(Query_word);
    while(Query_word_range.first!=Query_word_range.second){
        Get_text_line.insert(Query_word_range.first->second);
        Occurs_time++;
        Query_word_range.first++;
    }
    return Query_word_range;
}

void TextQuery::QueryPrint(){
    if(!Is_file_ok){
        cout <<"ERROR!! Could Not Open File!"<<endl;
        return;
    }

    if(!Occurs_time) cout <<"No search word"<<endl;
    else{
        cout <<"element occurs "<<Occurs_time<<" time :"<<endl;
        for(set<int>::const_iterator iter=Get_text_line.begin();iter!=Get_text_line.end();iter++){
            cout <<*iter<<" "<<Text_file[*iter-1]<<endl;
        }
    }    
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

class Query_base{
friend class Query;    
public:
    virtual ~Query_base(){}    
private:
    virtual TextQuery::multi_word_range eval(const TextQuery&)const=0;
    virtual ostream& display(ostream& =cout)const=0;
};

class Query{
friend Query operator~(const Query&);
friend Query operator&(const Query&,const Query&);
friend Query operator|(const Query&,const Query&);
public:
    TextQuery::multi_word_range eval(const TextQuery &t)const{return pq->eval(t);}
    ostream& display(ostream& os)const{return pq->display(os);}
//constructor
    Query(const string &);
    Query(const Query &origin):pq(origin.pq),use(origin.use){*use++;}    
//destructor
    ~Query(){decr_use();}
//operator
Query& operator=(const Query&);    
private:
    void decr_use(){if (--*use==0)delete pq;delete use;}
    Query(Query_base *q):pq(q),use(new size_t(1)){};

    Query_base *pq;
    size_t *use;    
};
ostream& operator<<(ostream& os,const Query& Q){return Q.display(os);}


class WordQuery:public Query_base{
friend class Query;
    TextQuery::multi_word_range eval(TextQuery& t)const{return t.RUN_QW(QW);}
    ostream& display(ostream& os)const{return os<<QW;}
//constructor
    WordQuery(const string& s):QW(s){}
    private:
    string QW;
};


class NotQuery:public Query_base{
friend Query operator~(const Query&);
public:
    TextQuery::multi_word_range eval(const TextQuery& t)const;
    ostream& display(ostream& os)const{return os<<"~"<<"\""<<NQ<<"\"";}
//constructor    
    NotQuery(Query q):NQ(q){}
private:
    const Query NQ;    
};


class BinaryQuery:public Query_base{
    friend class Query;
public:
    ostream& display(ostream& os)const/*{return os<<" "<<LQ<<" "<<oper<<RQ;}*/;
//constructor
    BinaryQuery(Query L,Query R,string op):LQ(L),RQ(R),oper(op){}    
private:
    const Query LQ,RQ;
    const string oper;    
};


class AndQuery:public BinaryQuery{
friend Query operator&(const Query& q1,const Query& q2);
public:
    TextQuery::multi_word_range eval(const TextQuery&)const;
//constructor
    AndQuery(Query L,Query R):BinaryQuery(L,R,"&"){}        
};


class OrQuery:public BinaryQuery{
friend Query operator|(const Query& q1,const Query& q2);
public:
    TextQuery::multi_word_range eval(const TextQuery&)const;
//constructor
    OrQuery(Query L,Query R):BinaryQuery(L,R,"|"){}    
};

inline Query operator~(const Query& q){return new NotQuery(q);}
inline Query operator&(const Query& q1,const Query& q2){return new AndQuery(q1,q2);}
inline Query operator|(const Query& q1,const Query& q2){return new OrQuery(q1,q2);}