C++程序设计原理与实践 第十章部分答案

#include "../../st.h"

class Point{
public:
    Point():x(0),y(0){}
    Point(int x1,int y1):x(x1),y(y1){}
    double re_x(){return x;}
    double re_y(){return y;}
    friend istream& operator>>(istream&is,Point&p);
private:
    double x; 
    double y;
};

ostream& operator<<(ostream& os,Point&p)
{
    return os<<"("<<p.re_x()<<","<<p.re_y()<<")";
}


istream& operator>>(istream&is,Point&p)
{
    char c1,c2,c3;
    is>>c1>>p.x>>c2>>p.y>>c3;
    return is;
}


void fill_from_file(vector<Point>&p,string&s)
{
    ifstream ist(s.c_str());
    if(!ist)
        error("can't open input file",s);
    Point pp;
    while(ist>>pp)
        p.push_back(pp);
}

void file_from_fill(vector<Point>&p,string&s)
{
    ofstream ost(s.c_str());
    int i;
    if(!ost)
        error("can't open output file",s);
    for(i=0;i<p.size();i++)
        ost<<'('<<p[i].re_x()<<','<<p[i].re_y()<<')'<<endl;
}

int main()
{
    int i;
    int x,y;
    vector<Point> original_points;
    vector<Point> processed_points;
    string oname="output.txt";
    
    for(i=0;i<7;i++)
    {
        cout<<i+1<<"  输入（x，y）:";
        cin>>x>>y;
        Point p(x,y);
        original_points.push_back(p);
    }
    
    file_from_fill(original_points,oname);
    fill_from_file(processed_points,oname);
    
    
    for(i=0;i<7;i++)
        cout<<original_points[i]<<endl;
    for(i=0;i<7;i++)
        cout<<processed_points[i]<<endl;
    keep_window_open();
        
}

#include "../../st.h"

int main()
{
    string s="mydata.txt";
    int i;
    int sum=0;
    ifstream ist(s.c_str());
    if(!ist)
        error("can't open input file",s);
    while(ist>>i)
    {
        sum+=i;
    }
    cout<<sum<<endl;
    keep_window_open();
        
}         

#include "../../st.h"

struct Reading{
    int hour;
    double temperature;
    char c;
    Reading(int h,double t,char ch):hour(h),temperature(t),c(ch){}
};

ostream& operator<<(ostream&os,Reading&r)
{
    return os<<r.hour<<','<<r.temperature<<r.c<<endl;
}

istream& operator>>(istream&is,Reading&r)
{
    char c;
    is>>r.hour>>c>>r.temperature>>r.c;
    return is;
}

void change(Reading&r)
{
    if(r.c=='c')
    {
        r.c='f';
        r.temperature=32+r.temperature*1.8;
    }

}

void fill_from_file(vector<Reading>&r,string&s)
{
    ifstream ist(s.c_str());
    if(!ist)
        error("can't open input file",s);
    Reading rr(0,0,'c');
    while(ist>>rr)
    {
        change(rr);
        r.push_back(rr);
    }
}


int main()
{
    string s="mydata.txt";
    int hour;
    double tem;
    char ch;
    vector<Reading> readings;
    ofstream ost(s.c_str());
    if(!ost)
        error("can't open output file",s);
    while(cin>>hour>>tem>>ch)
    {
        if(hour<0||hour>23)
            error("hour out if range");
        ost<<Reading(hour,tem,ch);
    }
    ost.close();

    fill_from_file(readings,s);
    int i,j;
    int h,t;
    for(i=0;i<readings.size();i++)
        for(j=0;j<readings.size()-i-1;j++)
            if(readings[j].temperature>readings[j+1].temperature)
            {
                h=readings[j].hour;
                t=readings[j].temperature;
                readings[j].hour=readings[j+1].hour;
                readings[j].temperature=readings[j+1].temperature;
                readings[j+1].hour=h;
                readings[j+1].temperature=t;
            }
    double sum=0;
    for(i=0;i<readings.size();i++)
        sum+=readings[i].temperature;
    cout<<"middle:"<<readings[readings.size()/2].temperature<<endl<<"平均:"<<sum/readings.size()<<endl;

    keep_window_open();
        
}        

void print_year(ofstream&ofs,Year&y)
{
    ofs<<y.year<<"   year:\n";
    for(int i=0;i<12;i++)
    {
        if(y.month[i].month!=not_a_month)
        {
            ofs<<"\tmonth  "<<y.month[i].month<<endl;
            for(int j=0;j<32;j++)
            {
                if(y.month[i].day[i].is_day!=not_a_day)
                {
                    ofs<<"\t\tday  "<<y.month[i].day[i].is_day<<endl;
                    for(int k=0;k<24;k++)
                        if(y.month[i].day[i].hour[k]!=not_a_reading)
                            ofs<<"\t\t\t"<<i<<" hour: "<<y.month[i].day[i].hour[k]<<endl;
                }

            }
        }
    }
}    

#include "../../st.h"

class Roman_int{
public:
    int as_int(string s);
    int re_int(){return i;}
    char re_kind(){return ch;}
    Roman_int()
        :i(0){}
    Roman_int(char c)
        :ch(c),i(0){}
    Roman_int(char c,int ii)
        :ch(c),i(ii){}
private:
    int i;
    char ch;
};

string as_roman(int i)
{
    if(i<1||i>>3999)
        error("over range 1~3999");
    string digits[10] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
    string tens[10] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
    string hundreds[10] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
    string thousands[4] = {"", "M", "MM", "MMM"};

    string ss="";
    ss+=thousands[i/1000];
    ss+=hundreds[i%1000/100];
    ss+=tens[i%100/10];
    ss+=digits[i%10];

    return ss;
}

int Roman_int::as_int(string s)
{
    int b[100];
    int sum=0;
    int i1=0,sum1=0;
    for(i1=0;i1<s.size();i1++)
    {
        switch(s[i1])
        { 
            case 'I':b[i1]=1,sum1++;continue;
            case 'V':b[i1]=5,sum1++;continue;
            case 'X':b[i1]=10,sum1++;continue;
            case 'L':b[i1]=50,sum1++;continue;
            case 'C':b[i1]=100,sum1++;continue;
            case 'D':b[i1]=500,sum1++;continue;
            case 'M':b[i1]=1000,sum1++;continue;
            default: break;
        }
    }
    if(sum1==1)
        sum=b[0];
    else
    {
      sum=0;
      for(i1=0;i1<sum1;i1++)
      {  
          if(b[i1]>=b[i1+1])
              sum=sum+b[i1];
          else
          {
              sum=sum+(b[i1+1]-b[i1]);
              i1++;
          }
      } 
    }
    i=sum;
    return sum;
}

istream& operator>>(istream&is,Roman_int&ri)
{
    string s;
    is>>s;
    ri.as_int(s);
    return is;
}

ostream& operator<<(ostream&os,Roman_int&ri)
{
    return os<<ri.re_int();
}

class Token_stream{
public:
    Token_stream();
    Roman_int get();
    Roman_int get(istream&);
    void putback(Roman_int ri);
private:
    bool full;
    Roman_int buffer;
};

Token_stream::Token_stream()
    :full(false),buffer(0)
{
}

void Token_stream::putback(Roman_int t)
{
    if(full) error("putback() into a full buffer");
    buffer=t;
    full=true;
}

Roman_int Token_stream::get(istream&ifs)
{
    if(full){
        full=false;
        return buffer;
    }
    char ch;
    ifs>>ch;
    switch(ch){
    case ';': case 'q': case '(': case ')': case '{':
    case '}':  case '+': case '-': case '*': case '/':
        return Roman_int(ch);
    case 'I': case 'V': case 'X': 
    case 'C': case 'D': case 'M':
        { 
            string s="";
            s+=ch;
            while(ifs>>ch)
            {
                if(ch=='I'||ch=='V'||ch=='X'||ch=='C'||ch=='D'||ch=='M')
                    s+=ch;
                else
                {
                    ifs.putback(ch);
                    break;
                }
            }
            Roman_int r('8');
            r.as_int(s);
            return r;
        }
    case 'f': 
        while(cin.get(ch)&&isalpha(ch))   
                ;
            cin.putback(ch);
            return Roman_int('f');
    case 't':
            while(cin.get(ch)&&isalpha(ch))   
                ;
            cin.putback(ch);
            return Roman_int('t');
    default:
        error("bad token");
        }
}

Token_stream ts;
double expression(istream&ifs);

double primary(istream&ifs)
{

    Roman_int t=ts.get(ifs);
    switch(t.re_kind()){
    case '(':
    {
        int d=expression(ifs);
        t=ts.get(ifs);
        if(t.re_kind()!=')')  
            error("')'expected");
        return d;
    }
    case '8':
        return t.re_int();
    default:
        error("primary expected",t.re_kind());
    }
}

double primary1(istream&ifs)
{
    Roman_int t=ts.get(ifs);
    while(true)
    {
        switch(t.re_kind()){
        case '{':
        {
            double d=expression(ifs);
            t=ts.get(ifs);
            if(t.re_kind()!='}')  
                error("'}'expected");
            return d;
        }
        default:
            ts.putback(t);
            return primary(ifs);
        }
    }
}

double term(istream&ifs)
{
    double left=primary1(ifs);
    Roman_int t=ts.get(ifs);

    while(true){
        switch(t.re_kind()){
        case '*':
            left*=primary1(ifs);
            t=ts.get(ifs);
            break;
        case '/':
            {
                double d=primary1(ifs);
                if(d==0)
                    error ("divide by 0");
                left /=d;
                t=ts.get(ifs);
                break;
            }
        default:
            ts.putback(t);
            return left;
        }
    }
}

double expression(istream&ifs)
{
    double left=term(ifs);
    Roman_int t=ts.get(ifs);
    while(true){
        switch(t.re_kind()){
        case '+':
            left+=term(ifs);
            t=ts.get(ifs);
            break;
        case '-':
            left-=term(ifs);
            t=ts.get(ifs);
            break;
        default:
            ts.putback(t);
            return left;
        }
    }
}

int main()
{
    try{
    double val=0;
    Roman_int t;
    while(cin)
    {
        t=ts.get(cin);


        if(t.re_kind()=='f')
        {
            double val1=0;
            string s;
            cin>>s;
            ifstream ifs(s.c_str());
            if(!ifs)
                error("can not open input file1",s);
            t=ts.get(cin);
            if(t.re_kind()=='t')
            {
                cin>>s;
                ofstream ofs(s.c_str());
                if(!ofs)
                    error("can not open output file1",s);
                while(ifs)
                {
                    t=ts.get(ifs);
                    while(t.re_kind()==';')
                        t=ts.get(ifs);
                    if(t.re_kind()=='q') 
                        break;
                    ts.putback(t);
                    ofs<<as_roman(expression(ifs))<<endl;
                }
            }
        }
        else
        {

            while(t.re_kind()==';')
                t=ts.get(cin);
            if(t.re_kind()=='q') 
            {
                keep_window_open("~~");
                return 0;        
            }        
            ts.putback(t);
            cout<<as_roman(expression(cin))<<endl;
        }
    }
    return 0;

    }

catch(exception&e){
    cerr<<e.what()<<endl;
    while(1);
    return 1;
}

catch(...){
    cerr<<"exception\n";
    while(1);
    return 2;
}
    
}

void fn(string&a,string&b,string&c)
{
    ifstream ifs1(a.c_str());
    if(!ifs1)
        error("can not open input file1",a);
    ifstream ifs2(b.c_str());
    if(!ifs2)
        error("can not open input file1",b);
    vector<string> s;
    string ss;
    while(ifs1>>ss)
        s.push_back(ss);
    while(ifs2>>ss)
        s.push_back(ss);
    sort(s.begin(),s.end());//习题9
    ofstream ofs(c.c_str());
    if(!ofs)
        error("can not open output file1",c);
    for(int i=0;i<s.size();i++)
        ofs<<s[i]<<' ';
}

#include "../../st.h"

int main()
{
    string s1="a.txt";
    double sum=0;
    double d;
    char ch;
    ifstream ifs(s1.c_str());
    if(!ifs)
        error("can not open input file1",s1);
    while(ifs>>ch)
    {
        if(isdigit(ch))
        {
            ifs.putback(ch);
            ifs>>d;
            sum+=d;
        }
    }

    cout<<sum<<endl;
    keep_window_open();
}

//用到第十一章内容

#include "../../st.h"

int main()
{
    string s1="a.txt";
    string str1;
    string s;
    int i=0;
    cout<<"input the word:";
    cin>>str1;
    ifstream ifs(s1.c_str());
    if(!ifs)
        error("can not open input file1",s1);
    while(getline(ifs,s))
    {
        i++;
        stringstream ss(s);
        string str;
        while(ss>>str)
        {
            if(str==str1){
                cout<<i<<"    "<<s<<endl;
                break;
            }
        }

    }

    keep_window_open();
}