oop-实验6

task1

contestant.hpp

#pragma once

#include<iomanip>
#include<iostream>
#include<string>

struct Contestant{
    //学号/姓名/专业
    long id;
    std::string name; 
    std::string major; 
    int solved;   //解题数
    int penalty;  //总罚时
};

//重载<<,要求：姓名/专业里不含空白符
inline std::ostream& operator<<(std::ostream &out,const Contestant& c){
    out<<std::left;
    out<<std::setw(15)<<c.id
       <<std::setw(15)<<c.name
       <<std::setw(20)<<c.major
       <<std::setw(10)<<c.solved
       <<std::setw(10)<<c.penalty;
    return out;
}

//重载>>，这个函数就是输入Contestant对象
inline std::istream& operator>>(std::istream& in,Contestant& c){
    in>>c.id>>c.name>>c.major>>c.solved>>c.penalty;
    return in;
}

utils.hpp

#pragma once

#include<fstream>
#include<iostream>
#include<stdexcept>
#include<string>
#include<vector>
#include"contestant.hpp"

//ACM排序规则：先按解题数降序，再按罚时升序
inline bool cmp_by_solve(const Contestant& a,const Contestant& b){
    return a.solved!=b.solved?a.solved>b.solved:a.penalty<b.penalty;
}

//将结果写至任意输出流
inline void write(std::ostream& os,const std::vector<Contestant>& v){
    for(const auto& x:v)
        os<<x<<"\n";
}

//将结果打印到屏幕,其实就相当于调用了write函数只不过函数参数传递是cout就变成了将结果打印到屏幕上了
inline void print(const std::vector<Contestant>& v){
    write(std::cout,v);
}

//将结果保存到文件
inline void save(const std::string& filename,const std::vector<Contestant>& v){
    std::ofstream os(filename);
    if(!os){
        throw std::runtime_error("fail to open"+filename);
    }
    write(os,v);
}

//从文件读取信息（跳过标题行）
inline std::vector<Contestant> load(const std::string& filename){
    std::ifstream is(filename); 
    if(!is){
        throw std::runtime_error("fail to open"+filename);
    }
    std::string line;
    std::getline(is,line); //跳过标题，这里getline的第一个参数只是需要一个输入流对象

    std::vector<Contestant> v;
    Contestant t;
    int seq;
    //这里is>>会根据读到的内容和读取变量
    while(is>>seq>>t) v.push_back(t);
    return v; 
}

task1.cpp

#include<algorithm>
#include<iostream>
#include<stdexcept>
#include<vector>
#include"contestant.hpp"
#include"utils.hpp"

const std::string in_file="./data.txt";
const std::string out_file="./ans.txt";

void app(){
    std::vector<Contestant> contestants;
    try{
        contestants=load(in_file);
        std::sort(contestants.begin(),contestants.end(),cmp_by_solve);
        print(contestants);
        save(out_file,contestants);
    }catch(const std::exception& e){
        std::cerr<<e.what()<<'\n';
        return;
    }
}

int main(){
    app();
}

终端打印结果

 ans.txt

 回答问题

问题1：流操作与代码复用
观察 print() 与 save() 的实现，均在内部调用 write() ：
（1） write() 的参数类型是 std::ostream& ，它为什么能同时接受 std::cout 和 std::ofstream 对象作为实参？
　　std::cout是std::ostream本身创建的实例，std::ofstream是std::ostream的派生类,基类的引用是可以绑定到派生类对象上面的，也就是多态。

（2）如果要把结果写到其他设备，只要该设备也提供 std::ostream 接口，还需改动 write() 吗？
　　不用改动，write()函数需要一个ostream&,只要该设备的接口继承自std::ostream就ok。

问题2：异常处理与捕获
在代码中找到两处 throw 语句，说明：
throw std::runtime_error("fail to open"+filename);
（1）什么情况下会抛出异常；
　　文件打开失败时会抛出异常。
（2）异常被谁捕获、做了哪些处理。
　　这两个异常都是在app()函数中try{}模块调用的save(),load()函数里的，发生异常时会被catch块捕捉。
　　然后catch块中cerr是用来输出错误信息的流，调用e.what()获取异常的具体描述信息，最后return，程序就安全地退出这个函数了。

问题3：替代写法
函数 app 中 std::sort(contestants.begin(), contestants.end(), cmp_by_solve);
参数cmp_by_solve 换成下面的lambda表达式是否可以？功能、性能、结果是否一致？[](const Contestant& a, const Contestant& b) {
return a.solved != b.solved ? a.solved > b.solved: a.penalty < b.penalty;}
　　嗯结果是一致的，性能方面lambda表达式通常是更快的，没有调用函数的额外开销。

问题4：数据完整性与代码健壮性
把 in_file 改成 "./data_bad.txt" （内含空白行或字段缺失），重新编译运行：
（1）观察运行结果有什么问题？给出测试截图并分析原因。

　　打印出来的结果数据是错误的，紊乱的。
　　load函数中的is输入流对象在读取的时候会自动忽略前导空百符（如空格和换行），所以读到第4行的时候因为整行的数据都是缺失的就直接一起都跳过了
　　但是当读到第10行时，这一行的数据中的解题数和总罚时都缺失，所以就跳过空白将第10行的序号8读成了解题数，将学号读成了罚时，这两个能成功读取是因为类型能跟int匹配上
　　但是接下来的该读到int的时候读到了string类型的name，就读取失败了，退出。后面三个人的数据直接就没读进去。
（2）思考：如何修改函数 std::vector<Contestant> load(const std::string& filename) ，使其提示出错行号并跳过有问题的数据行，同时让程序继续执行？（选答*）

　　我想的是每行读取，然后放到sstream对象中判断该行是否正确

 测试一下

 

 

task2

student.hpp

#pragma once

#include<iostream>
#include<string>

class Student{
public:
    Student()=default;
    ~Student()=default;

    const std::string& get_major() const;
    int get_grade() const;

    friend std::ostream& operator<<(std::ostream& os,const Student& s);
    friend std::istream& operator>>(std::istream& is,Student& s);
private:
    int id;
    std::string name;
    std::string major;
    int grade; //0-100
};

student.cpp

#include<iostream>
#include<string>
#include<iomanip>
#include"student.hpp"

const std::string& Student::get_major() const{
    return major;
}

int Student::get_grade() const{
    return grade;
}

std::ostream& operator<<(std::ostream& os,const Student& s){
    os<<std::left;
    os<<std::setw(10)<<s.id
      <<std::setw(10)<<s.name
      <<std::setw(10)<<s.major
      <<std::setw(10)<<s.grade;
    return os;
}
std::istream& operator>>(std::istream& is,Student& s){
    is>>s.id>>s.name>>s.major>>s.grade;
    return is;
}

stumgr.hpp

#pragma once 
#include<string>
#include<vector>
#include"student.hpp"

class StuMgr{
public:
    void load(const std::string& file); //加载数据文件（空格分隔）
    void sort(); //排序：按专业字典序升序，同专业分数降序
    void print() const; //打印到屏幕
    void save(const std::string &file ) const; //保存到文件

private:
    void write(std::ostream &os) const;  //把数据写到任意输出流

    std::vector<Student> students;
};

stumgr.cpp

#include<string>
#include<vector>
#include<fstream>
#include<algorithm>
#include<sstream>
#include"student.hpp"
#include"stumgr.hpp"
void StuMgr::load(const std::string& file){
    std::ifstream is(file);
    if(!is){
        throw std::runtime_error("fail to open"+file);
    }
    std::string str;
    std::getline(is,str);
    Student s;
    while(is>>s) students.push_back(s);
}

void StuMgr::sort(){
    std::sort(students.begin(),students.end(),[](const Student& s1,const Student& s2){
        return s1.get_major()!=s2.get_major()?s1.get_major()<s2.get_major():s1.get_grade()>s2.get_grade();
    });
}

void StuMgr::print() const{ //打印到屏幕
    write(std::cout);
}
 
void StuMgr::save(const std::string& file) const{ //保存到文件
    std::ofstream os(file);
    if(!os){
        throw std::runtime_error("fail to open"+file);
    }
    write(os);
}

void StuMgr::write(std::ostream &os) const{ //把数据写到任意输出流
    for(auto s:students){
        os<<s<<"\n";
    }
}

task2.cpp

#include<iostream>
#include<limits>
#include<string>
#include"stumgr.hpp"

const std::string in_file="./data.txt";
const std::string out_file="./ans.txt";

void menu(){
    //这里出现的多引号连续放置编译器会自动拼接"+"为一个字符串，所以这里并没有加<<
    std::cout<<"\n**********简易应用**********\n"
                "1. 加载文件\n"
                "2. 排序\n"
                "3. 打印到屏幕\n"
                "4. 保存到文件\n"
                "5. 退出\n"
                "请选择：";
}

void app(){
    StuMgr mgr;
    while(true){
        menu();
        int choice;
        std::cin>>choice;
        try{
            switch(choice){
                case 1:mgr.load(in_file);
                    std::cout<<"加载成功\n"; break;
                case 2:mgr.sort();
                    std::cout<<"排序已完成\n"; break;
                case 3:mgr.print();
                    std::cout << "打印已完成\n"; break;
                case 4:mgr.save(out_file);
                    std::cout << "导出成功\n"; break;
                case 5: return;
                default: std::cout<<"不合法输入\n";
            }
        }catch(const std::exception& e){
            std::cout<<"Error:"<<e.what()<<'\n';
        }
    }
}

int main(){
    app();
}

终端运行结果

ans.txt

选做*：为数据完整性、有效性（如文件字段是否有缺失、成绩值是否合法）提供异常处理

 方法我想的是还是用字符串流...跟task1有点像吧

 主要改动的代码其实就是load函数中读取数据的部分，先判断一下是否合理，如果合理的话再读取，不合理的话直接打印出错误信息然后跳到下一行

void StuMgr::load(const std::string& file){
    std::ifstream is(file);
    if(!is){
        throw std::runtime_error("fail to open"+file);
    }
    std::string str;
    std::getline(is,str); //先读取第一行标题
    /*
    Student s;
    while(is>>s) students.push_back(s);
    */
    /*
    上面注释部分是未进行数据校验的写法，下面是更安全的做法
    
    题目：如希望加载文件时提供异常处理，包括对字段缺失、成绩值不在有效范围内内做校验，使得代码更健壮：有字段缺失
    或异常值不会参与计算，如何完善代码，使其预期效果如下：报告错误行信息，同时并不影响其它有效数据计算。
    */
    std::string line;
    int num=1; //记录此时所在的行数
    while(std::getline(is,line)){
        num++;
        if(line.empty()) continue;
        std::istringstream iss(line);
        int id,grade;
        std::string name,major;
        if(!(iss>>id>>name>>major>>grade)){
            std::cout<<"[Warning] line"<<num<<" format error,skipped: "<<line+"\n";
            continue;
        }else if(grade<0||grade>100){
            std::cout<<"[Warning] line"<<num<<" grade invalid,skipped:"<<line+"\n";
            continue;
        }
        Student s;
        std::istringstream new_iss(line);
        new_iss>>s;
        students.push_back(s);
    }
}

终端测试，错误信息正确打印

 其余正确的数据正常排序&print

 ans.txt导出也成功

 

感悟

<sstream>用得有点顺手了😊

 一学期真快...

 一年真快...去年这个时候也差不多写完c语言的IO实验