苏州大学2014，2015年C++程序设计与实验第三次测试题解

2014年
有以下用于表示商场商品信息的CGoods类定义。

class CGoods
{
private:
    int m_num;    //商品编号
    string m_name;    //商品名称
    float m_price;    //商品价格

public:
    CGoods (int, const string&, float);
    friend ostream& operator<<(ostream&, const CGoods&);
//商品名称、商品编号和商品价格的显示格式都要求为占10列、右对齐
};

请按照如下要求完成相应程序：

1. 实现CGoods类的所有成员函数；
2. 以CGoods类为基类，定义CRouter子类，用于表示商场所销售的路由器商品信息。要求该类必须要具有如下成员变量和成员函数：
   a) 用于表示路由器信号频率的变量，float类型
   b) 用于表示路由器端口数量的变量，int类型
   c) 有参构造函数，如不给定初值则各成员变量取初值如下：
   商品编号：1
   商品名称："M8"
   商品价格：100.0
   信号频率：2.4
   端口数量：8
   d) 获取路由器端口数量的成员函数GetChannels；
   e) 获取路由器信号频率的成员函数GetFrequency；
   f) 前自增运算符重载函数，实现端口数量加1的操作；
   g) 后自增运算符重载函数，实现端口数量加1的操作；
   h) 流输出符“<<”重载函数，实现对路由器商品全部信息的显示，基类部分成员的显示格式要求与CGoods类部分相同，信号频率和端口数量的显示格式都要求为占10列、右对齐。
3. 在上述CGoods类和CRouter类的基础上，请按照下列要求分别编写3个函数：
   a) 编写一个函数，从文本文件中读取数量未知个路由器商品数据，构成一个向量。该文本文件中每条路由器商品信息中顺序包含了商品编号、商品名称、商品价格、信号频率、端口数量，每条数据占1行。
   b) 编写一个函数，显示向量中所有路由器商品数据，每条数据占1行。
   c) 编写一个函数，查找到向量中“端口数量和信号频率的乘积”最大的那个元素。
4. 通过如下所示的主函数对CGoods类、CRouter类和上述3个函数的功能进行验证

void main()
{
    vector<CRouter> s;

    ReadData(s,"D:\\Data.txt");
    cout<<"读取完成后的向量为"<<endl;
    DisplayData(s);

    CRouter t;
    cout<<endl<<"路由器对象的初始值为"<<endl<<t<<endl;

    t=FindMax(s);
    cout<<endl<<"乘积最大的向量元素为"<<endl<<t<<endl;

    cout<<endl<<"乘积最大的向量元素进行自增运算结果分别如下:"<<endl;
    cout<<t++<<endl;
    cout<<t<<endl;

    cout<<++t<<endl;
    cout<<t<<endl;
}

以下是答案代码，可能换行有点瑕疵，但我懒得改了。

//author CN.TTDragon
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <iterator>
#include <sstream>
#include <algorithm>
#include<string>
#include<cmath>
#include<cstdio>
typedef long long ll;
const ll mod=1e9+7;
const ll maxn=1e5+7;
const double pi=acos(-1);
using namespace std;
class CGoods
{
private:
    int m_num;    //商品编号
    string m_name;    //商品名称
    float m_price;    //商品价格

public:
    CGoods (int num, const string& name, float price)
    {
        m_num=num;
        m_name=name;
        m_price=price;
    }
    friend ostream& operator<<(ostream& os, const CGoods& obj)
//商品名称、商品编号和商品价格的显示格式都要求为占10列、右对齐
    {
        os<<setw(10)<<right<<obj.m_name
          <<setw(10)<<right<<obj.m_num
          <<setw(10)<<right<<obj.m_price;
        return os;
    }
};

class CRouter : public CGoods
{
    private:
        float m_fre;//信号频率
        int m_cha;//端口数量  
    public:
        CRouter(int num=1, const string& name="M8", float price=100.0,float fre=2.4,int cha=8  ):CGoods(num,name,price)
        {
            m_fre=fre;
            m_cha=cha;
        }
        int GetChannels()
        {
            return m_cha;
        }
        float GetFrequency()
        {
            return m_fre;
        }

        friend CRouter & operator ++(CRouter & obj)
        {
            obj.m_cha++;
            return obj;
        } 
        friend CRouter  operator ++(CRouter & obj,int b)
        {
            CRouter temp(obj); 
            obj.m_cha++;
            return temp;
        } 
        friend ostream& operator<<(ostream& os, const CRouter& obj)
        {
            os<<static_cast<const CGoods&>(obj);
            os<<setw(10)<<right<<obj.m_fre
              <<setw(10)<<right<<obj.m_cha<<endl;

            return os;

        }
};

void ReadData(vector<CRouter> &s,string name)
{
    ifstream in(name.c_str());
    int num;
    string mname;
    float price;
    float fre;
    int cha;
    while(in>>num>>mname>>price>>fre>>cha)
    {
        CRouter temp(num,mname,price,fre,cha);
        s.push_back(temp);
    }
}
void DisplayData(vector<CRouter> &s)
{
    for (size_t i=0;i<s.size();i++)
    {
        cout<<s[i];
    }

}

CRouter FindMax(vector<CRouter> &s)
{
    float mx=s[0].GetChannels()*s[0].GetFrequency();
    float place=0;
    for (size_t i=0;i<s.size();i++)
    {
        if(mx<s[i].GetChannels()*s[i].GetFrequency())
        {
            mx=s[i].GetChannels()*s[i].GetFrequency();
            place=i;
        }
    }
    return s[place];
}

int  main()
{
    vector<CRouter> s;

    ReadData(s,"f:\\C++\\homework\\2014-3\\Data.txt");
    cout<<"读取完成后的向量为"<<endl;
    DisplayData(s);

    CRouter t;
    cout<<endl<<"路由器对象的初始值为"<<endl<<t<<endl;

    t=FindMax(s);
    cout<<endl<<"乘积最大的向量元素为"<<endl<<t<<endl;

    cout<<endl<<"乘积最大的向量元素进行自增运算结果分别如下:"<<endl;
    cout<<t++<<endl;
    cout<<t<<endl;

    cout<<++t<<endl;
    cout<<t<<endl;
    return 0;
}

以下是Date.txt

114 S5 5280.0 2.4 4
26 S2 3090.0 5.0 16
325 S3 3560.0 2.4 32
42 S4 4130.0 5.0 8
163 S1 1800.5 2.4 8

2015年:
很多家用电器中都有电机（或称马达）。用于表示家用电器中电机的类Motor的定义如下所示

class Motor
{
private:
        int m_Type;            //电机类型 0-直流 1-交流
        int m_Power;            //电机功率（必须为正数）

public:
        Motor(int Type, int Power);
        int GetPower()const;        //读取电机功率
        int SetPower(int Power);        //修改电机功率，返回值表示修改是否成功，0-失败 1-成功
        friend ostream& operator<<(ostream &Out, const Motor &Obj);
};

在上述类定义的基础上，实现该类的所有成员函数和友元函数。其中，流输出符重载中显示电机信息的格式要求为：
（1） 电机类型：占4列，右对齐，0显示为DC，1显示为AC
（2） 电机功率：占6列，右对齐

用于表示家用电器的类

class Appliance
{
private:
    string m_Name;
    double m_Weight;        //重量（必须为正数）

public:
    Appliance(const string &Name, double Weight);
    double GetWeight()const;        //读取重量
    int SetWeight(double Weight);        //修改重量，返回值表示修改是否成功，0-失败 1-成功
    friend ostream& operator<<(ostream &Out, const Appliance &Obj);
};

在上述类定义的基础上，实现该类的所有成员函数和友元函数。其中，流输出符重载中显示家用电器信息的格式要求为：
（1） 名称：占6列，右对齐
（2） 重量：占6列，小数点保留1位，右对齐
请按要求编写一个类WashMachine，用于描述洗衣机。WashMachine类的要求如下：
（1） Appliance类为WashMachine类的public基类；
（2） WashMachine类包含以下数据成员：
洗衣机的电机部件m_Motor，Motor类型
洗衣容积m_Volume，int类型，必须为正数。
注意：上述2个数据成员均为私有。
（3） 请设计提供1个带有5个参数的构造函数，各参数的顺序分别为：电器名称、电机类型、电机功率、电器重量和洗衣容积，各参数的数据类型请自己决定。如不给定初值则各成员变量取初值如下：
电器名称：”M9”
电机类型：0
电机功率：20
电器重量：20.0
洗衣容积：20
（4） 请设计用于获取洗衣机洗衣容积的常成员函数GetVolume。
（5） 请设计前自增运算符++重载函数。其含义为：电机功率增加10，电器重量增加10.0，洗衣容积增加10。
（6） 请设计后自增运算符++重载函数。自增规则同前。
（7） 请设计流输出运算符重载函数，用于显示洗衣机的所有信息，格式要求如下：
名称：与Appliance类中格式要求相同
重量：与Appliance类中格式要求相同
电机类型：与Motor类中格式要求相同
电机功率：与Motor类中格式要求相同
洗衣容积：占5列，右对齐

在上述类定义的基础上，请按照下列要求分别编写4个函数：
（1） 编写一个函数ReadFileData，从文本文件中读取数量未知个洗衣机的数据，构成一个洗衣机向量。该文本文件中每条洗衣机信息中顺序包含了名称、重量、电机类型、电机功率和洗衣容积，每条数据占1行。
（2） 编写一个函数DisplayData，显示洗衣机向量中所有商品数据，每条数据占1行。
（3） 编写一个函数FindData，查找到洗衣机向量中“洗衣容积大于X”的所有洗衣机数据，并将这些查找得到的结果数据通过一个新的向量来进行返回。其中X表示查找的最小洗衣容积值，int类型。
（4） 再编写一个函数FindData，查找到洗衣机向量中“重量大于Y”的所有洗衣机数据，并将这些查找得到的结果数据通过一个新的向量来进行返回。其中Y表示查找的最小重量值，double类型。
通过如下所示的主函数对上述3个类和4个函数的功能进行验证

void main()
{
    vector<WashMachine> data,res;

    if (ReadFileData("d:\\info.txt", data)==0)
        return;

    cout<<"文件读取完成后的洗衣机信息如下:"<<endl;
    DisplayData(data);

    res = FindData(data, 30);
    cout<<endl<<"洗衣容积大于30的洗衣机信息如下所示:"<<endl;
    DisplayData(res);

    res = FindData(data, 20.0);
    cout<<endl<<"重量大于20.0的洗衣机信息如下所示:"<<endl;
    DisplayData(res);

    WashMachine d;
    cout<<endl<<"新增加洗衣机对象及其自增运算结果如下所示:"<<endl;
    cout<<d<<endl;
    cout<<d++<<endl;
    cout<<d<<endl;
    cout<<++d<<endl;
    cout<<d<<endl;
}

牛客犯病了，以下是答案

//author CN.TTDragon
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <iterator>
#include <sstream>
#include <algorithm>
#include<string>
#include<cmath>
using namespace std;

class Motor
{
private:
        int m_Type;            //电机类型 0-直流 1-交流
        int m_Power;            //电机功率（必须为正数）

public:
        Motor(int Type, int Power)
        {
            m_Type=Type;
            m_Power=Power;
        }
        int GetPower()const//读取电机功率
        {
            return m_Power;
        }        
        int SetPower(int Power)        //修改电机功率，返回值表示修改是否成功，0-失败 1-成功
        {
            if(Power>0)
            {
                m_Power    =Power;
                return 1;
            }
            else
            {
                return 0;
            }
        }
        friend ostream& operator<<(ostream &Out, const Motor &Obj)
        {
            if(Obj.m_Type==0)
            {
                Out<<setw(4)<<right<<"DC";
            }
            else
            {
                Out<<setw(4)<<right<<"AC";
            }
            Out<<setw(6)<<right<<Obj.m_Power;
            return Out;
        } 
};

class Appliance
{
private:
    string m_Name;
    double m_Weight;        //重量（必须为正数）

public:
    Appliance(const string &Name, double Weight)
    {
        m_Name=Name;
        m_Weight=Weight;
    }
    double GetWeight()const        //读取重量
    {
        return m_Weight;
    }
    int SetWeight(double Weight)        //修改重量，返回值表示修改是否成功，0-失败 1-成功
    {
            if(Weight>0)
            {
                m_Weight=Weight;
                return 1;
            }
            else
            {
                return 0;
            }
    }
    friend ostream& operator<<(ostream &Out, const Appliance &Obj)
    {
        Out<<setw(6)<<right<<Obj.m_Name
        <<setw(6)<<fixed<<setprecision(1)<<Obj.m_Weight;
        return Out;
    }
};

class WashMachine:public Appliance
{
    private:
        Motor     m_Motor;
        int m_Volume;
    public:
        WashMachine(const string &Name="M9",int Type=0,int Power=20,double Weight=20.0f,int Volume=20):m_Motor(Type,Power),Appliance(Name,Weight)
        {

            m_Volume=Volume;
        }
        int GetVolume() const
        {
            return m_Volume;
        }

        friend WashMachine & operator++ (WashMachine &a)
        {
            a.m_Volume=a.m_Volume+10;
            a.SetWeight(a.GetWeight()+10);
            a.m_Motor.SetPower(a.m_Motor.GetPower()+10);
            return a ;
        }


        friend WashMachine  operator++ (WashMachine &a,int b)
        {
            WashMachine temp(a);
            a.m_Volume=a.m_Volume+10;
            a.SetWeight(a.GetWeight()+10);
            a.m_Motor.SetPower(a.m_Motor.GetPower()+10);
            return temp ;
        }

        friend ostream& operator<<(ostream &Out, const WashMachine &Obj)
        {    
            Out<<static_cast<const Appliance&>(Obj)
            <<Obj.m_Motor
            <<setw(5)<<right<< Obj.m_Volume<<endl;
            return Out;
        }

};


int ReadFileData(string filename,vector<WashMachine> &data)
{
    ifstream in(filename.c_str());
    if(!in)
    {
        return 0;
    }
    int cnt=0;
    string mname;
    double a;
    int b,c,d;
    while(in>>mname>>a>>b>>c>>d)
    {
        WashMachine qq(mname,b,c,a,d);
        data.push_back(qq);
        cnt++;
    }
    return cnt;
}
void DisplayData(vector<WashMachine> &data)
{
    for(size_t i=0;i<data.size();i++)
    {
        cout<<data[i];
    }
}

vector<WashMachine> FindData(vector<WashMachine> &data,int b)
{
    vector<WashMachine> res;
    for(size_t i=0;i<data.size();i++)
    {
        if(data[i].GetVolume()>b)
        {
            res.push_back(data[i]);
        }
    }
    return res;
}

vector<WashMachine> FindData(vector<WashMachine> &data,double b)
{
    vector<WashMachine> res;
    for(size_t i=0;i<data.size();i++)
    {
        if(data[i].GetWeight()>b)
        {
            res.push_back(data[i]);
        }
    }
    return res;
}

int  main()
{
    vector<WashMachine> data,res;

    if (ReadFileData("f:\\C++\\homework\\2015-3\\info.txt", data)==0)
        return 0;;

    cout<<"文件读取完成后的洗衣机信息如下:"<<endl;
    DisplayData(data);

    res = FindData(data, 30);
    cout<<endl<<"洗衣容积大于30的洗衣机信息如下所示:"<<endl;
    DisplayData(res);

    res = FindData(data, 20.0);
    cout<<endl<<"重量大于20.0的洗衣机信息如下所示:"<<endl;
    DisplayData(res);

    WashMachine d;
    cout<<endl<<"新增加洗衣机对象及其自增运算结果如下所示:"<<endl;
    cout<<d<<endl;
    cout<<d++<<endl;
    cout<<d<<endl;
    cout<<++d<<endl;
    cout<<d<<endl;
    return 0;
}
这里是info.txt
节水1 19.0 1 50 28
节水2 20.0 0 60 29
节水3 21.0 1 70 30
节水4 22.0 0 80 31