accelerated C++第七章 使用关联容器（7.4）

7.4
Grammer::const_iterator it=g.find(word);
map类的成员函数 find，根据特定的关键字来寻找查找元素。
若元素不存在，返回g.end()

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <algorithm>
#include <cctype>

using namespace std;
/规则的类型
typedef vector<string>Rule;
//规则集合的类型
typedef vector<Rule> Rule_collection;
//映射表的类型
typedef map<string,Rule_collection>Grammer;
bool space(char c);
bool not_space(char c);
vector<string>split(const string& str);
Grammer read_grammer(istream& in);
vector<string> gen_sentence(const Grammer& g);
bool bracketed(const string& s);
void gen_aux(const Grammer&g,const string &word,vector<string>&ret);
int nrand(int n);
bool space(char c)
{
    return(isspace(c));
}
bool not_space(char c)
{
    return !isspace(c);
}
vector<string>split(const string& str)
{
    typedef string::const_iterator iter;
    vector<string> ret;
    iter i=str.begin();
    while(i!=str.end())
    {
        i=find_if(i,str.end(),not_space);
        iter j=find_if(i,str.end(),space);
        if(i!=str.end())
            ret.push_back(string(i,j));
        i=j;
        }
    return ret;
    }
    return ret;
    //7.4生成句子
    //从一个特定的输入流读入一个文法
Grammer read_grammer(istream& in)
{
    Grammer ret;
    string line;
    //读输入
    cout<<"以行输入种类以及对应的规则";
    while(getline(in,line))
    {
        //把输入分割成单词
        vector<string>entry=split(line);
        if(!entry.empty())
            //用种类类存储相关联的规则
            ret[entry[0]].push_back(
                    Rule(entry.begin()+1,entry.end()));
    }
    return ret;
}
//定义句子的生成程序
vector<string> gen_sentence(const Grammer& g)
{
    vector<string>ret;
    gen_aux(g,"<sentence>",ret);
    return ret;
}
//判断一个单词是否代表了一种类
bool bracketed(const string& s)
{
    return s.size()>1&&s[0]=='<'&&s[s.size()-1]=='>';
}
//输出句子的规则规定
void gen_aux(const Grammer&g,const string &word,vector<string>&ret)
{
    if(!bracketed(word)){
        ret.push_back(word);
    }else{
        //为对应于word的规则定位
        Grammer::const_iterator it=g.find(word);
        if(it==g.end())
            throw logic_error("empty rule");
        //获取可能的规则集合
        const Rule_collection& c=it->second;
        //从规则集合中随机选择一条规则
        const Rule&r=c[nrand(c.size())];
        //递归展开所选定的规则
        for(Rule::const_iterator i=r.begin();i!=r.end();i++)
            gen_aux(g,*i,ret);
    }
}
//返回[0,n)中一个随机的整数
int nrand(int n)
{
    if(n<=0||n>RAND_MAX)
       throw domain_error("Argument to nrand is out of range");
    const int bucket_size=RAND_MAX/n;
    int r;
    do r=rand()/bucket_size;
        while(r>=n);
    return r;
}
int main()
{
    //生成句子
    vector<string> sentence=gen_sentence(read_grammer(cin));
    //输出第一个单词，如果存在的话
    vector<string>::const_iterator it=sentence.begin();
    if(!sentence.empty()){
        cout<<*it;
        ++it;
    }
    //输出其余的单词，每一个单词之后都有空格
    while(it!=sentence.end()){
        cout<<" "<<*it;
        it++;
    }
    cout<<endl;
    return 0;
}