oop-实验4 - fg

task1

GradeCalc.hpp

#pragma once

#include<vector>
#include<array>
#include<string>

class GradeCalc{
public:
    GradeCalc(const std::string &cname);
    void input(int n); // 录入n个成绩
    void output() const; // 输出成绩
    void sort(bool ascending = false); // 排序 (默认降序)
    int min() const; // 返回最低分（如成绩未录入，返回-1)
    int max() const; // 返回最高分 （如成绩未录入，返回-1)
    double average() const; // 返回平均分 （如成绩未录入，返回0.0)
    void info(); // 输出课程成绩信息

private:
    void compute();  //成绩统计

private:
    std::string course_name; // 课程名
    std::vector<int> grades; // 课程成绩
    std::array<int, 5> counts; // 保存各分数段人数（[0, 60), [60, 70), [70, 80), [80,90), [90, 100]
    std::array<double, 5> rates; // 保存各分数段人数占比
    bool is_dirty; // 脏标记，记录是否成绩信息有变更
};

GradeCalc.cpp

#include<algorithm>
#include<array>
#include<cstdlib>
#include<iomanip>
#include<iostream>
#include<numeric>
#include<string>
#include<vector>

#include"GradeCalc.hpp"

GradeCalc::GradeCalc(const std::string &cname):course_name(cname),is_dirty{true}{
    counts.fill(0);
    rates.fill(0);
}

void GradeCalc::input(int n){
    if(n<0){
        std::cerr<<"无效输入！人数不能为负数";
        std::exit(1);
    }
    grades.reserve(n);
    int grade;
    for(int i=0;i<n;){
        std::cin>>grade;
        if(grade<0||grade>100){
            std::cerr<<"无效输入！分数须在[0,100]\n";
            continue;
        }
        grades.push_back(grade);
        ++i;
    }
    is_dirty=true; //设置脏标记，成绩信息有变更
}

void GradeCalc::output() const{
    for(auto grade:grades) std::cout<<grade<<" ";
    std::cout<<std::endl;
}

void GradeCalc::sort(bool ascending){
    if(ascending) std::sort(grades.begin(),grades.end());
    else std::sort(grades.begin(),grades.end(),std::greater<int>());
} 

int GradeCalc::min() const{
    if(grades.empty()) return -1;
    auto it=std::min_element(grades.begin(),grades.end());
    return *it; 
} 

int GradeCalc::max() const{
    if(grades.empty()) return -1;
    auto it=std::max_element(grades.begin(),grades.end());
    return *it;
}

double GradeCalc::average() const{
    if(grades.empty()) return 0.0;
    double avg=std::accumulate(grades.begin(),grades.end(),0.0)/grades.size();
    return avg;
}

void GradeCalc::info(){
    if(is_dirty) compute();
    std::cout<<"课程名称:\t"<<course_name<<std::endl;
    std::cout<<"平均分:\t"<<std::fixed<<std::setprecision(2)<<average()<<std::endl;
    std::cout<<"最高分:\t"<<max()<<std::endl;
    std::cout<<"最低分:\t"<<min()<<std::endl;
    const std::array<std::string,5> grade_range{"[0, 60) ","[60, 70)","[70, 80)","[80, 90)","[90, 100]"};
    for(int i=grade_range.size()-1;i>=0;i--){
        std::cout<<grade_range[i]<<"\t:"<<counts[i]<<"人\t"<<std::fixed<<std::setprecision(2)<<rates[i]*100<<"%\n";
    }
}

void GradeCalc::compute(){  
    if(grades.empty()) return;
    counts.fill(0);
    rates.fill(0.0);
    //统计各分数段人数
    for(auto grade:grades){
        if(grade<60){
            ++counts[0];
        }else if(grade<70){
            ++counts[1];
        }else if(grade<80){
            ++counts[2];
        }else if(grade<90){
            ++counts[3];
        }else{
            ++counts[4];
        }
    }
    for(int i=0;i<rates.size();++i)
        rates[i]=counts[i]*1.0/grades.size();
    is_dirty=false;  //更新脏标记
}

demo1.cpp

#include<iostream>
#include<string>

#include"GradeCalc.hpp"

void test(){
    GradeCalc c1("OOP");
    std::cout<<"录入成绩：\n";
    c1.input(5);

    std::cout<<"输出成绩:\n";
    c1.output();
    
    std::cout<<"排序后成绩:\n";
    c1.sort();
    c1.output();
    
    std::cout<<"*************成绩统计信息*************\n";
    c1.info();
}
int main(){
    test();
}

运行结果

 回答问题：

 

 

task2

GradeCalc.hpp

#pragma once
#include<array>
#include<string>
#include<vector>

class GradeCalc:private std::vector<int>{
public:
    GradeCalc(const std::string &cname);
    void input(int n); // 录入n个成绩
    void output() const; // 输出成绩
    void sort(bool ascending = false); // 排序 (默认降序)
    int min() const; // 返回最低分（如成绩未录入，返回-1)
    int max() const; // 返回最高分 （如成绩未录入，返回-1)
    double average() const; // 返回平均分 （如成绩未录入，返回0.0)
    void info(); // 输出课程成绩信息

private:
    void compute();  //成绩统计

private:
    std::string course_name; // 课程名
    std::vector<int> grades; // 课程成绩
    std::array<int, 5> counts; // 保存各分数段人数（[0, 60), [60, 70), [70, 80), [80,90), [90, 100]
    std::array<double, 5> rates; // 保存各分数段人数占比
    bool is_dirty; // 脏标记，记录是否成绩信息有变更
};

GradeCalc.cpp

#include <algorithm>
#include <array>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#include "GradeCalc.hpp"

GradeCalc::GradeCalc(const std::string &cname): course_name{cname}, is_dirty{true}{
    counts.fill(0);
    rates.fill(0);
}

void GradeCalc::input(int n){
    if(n<0){
        std::cerr<<"无效输入! 人数不能为负数\n";
        return;
    }
    this->reserve(n);
    int grade;
    for(int i=0;i<n;){
        std::cin >> grade;
        if(grade < 0 || grade > 100) {
            std::cerr << "无效输入! 分数须在[0,100]\n";
            continue;
        }
        this->push_back(grade);
        ++i;
    }
    is_dirty=true;
}

void GradeCalc::output() const{
    for(auto g:*this)
        std::cout<<g<<' ';
    std::cout<<std::endl;
}

void GradeCalc::sort(bool ascending){
    if(ascending) std::sort(this->begin(),this->end());
    else std::sort(this->begin(),this->end(),std::greater<int>());
}

int GradeCalc::min() const{
    if(this->empty())
        return -1;
    return *std::min_element(this->begin(), this->end());
}

int GradeCalc::max() const{
    if(this->empty())
        return -1;
    return *std::max_element(this->begin(), this->end());
}

double GradeCalc::average() const {
    if(this->empty())
        return 0.0;
    double avg = std::accumulate(this->begin(), this->end(), 0.0) / this->size();
    return avg;
}
void GradeCalc::info() {
    if(is_dirty) compute();
    std::cout << "课程名称:\t" << course_name << std::endl;
    std::cout << "平均分:\t" << std::fixed << std::setprecision(2) << average() <<
    std::endl;
    std::cout << "最高分:\t" << max() << std::endl;
    std::cout << "最低分:\t" << min() << std::endl;
    const std::array<std::string, 5> grade_range{"[0, 60) ",
    "[60, 70)",
    "[70, 80)",
    "[80, 90)",
    "[90, 100]"};
    for(int i = grade_range.size()-1; i >= 0; --i)
        std::cout << grade_range[i] << "\t: " << counts[i] << "人\t"<< std::fixed << std::setprecision(2) << rates[i]*100 << "%\n";
}

void GradeCalc::compute() {
    if(this->empty())
        return;
    counts.fill(0);
    rates.fill(0);
    // 统计各分数段人数
    for(int grade: *this) {
        if(grade < 60)
            ++counts[0]; // [0, 60)
        else if (grade < 70)
            ++counts[1]; // [60, 70)
        else if (grade < 80)
            ++counts[2]; // [70, 80)
        else if (grade < 90)
            ++counts[3]; // [80, 90)
        else
            ++counts[4]; // [90, 100]
    }
    // 统计各分数段比例
    for(int i = 0; i < rates.size(); ++i)
        rates[i] = counts[i] * 1.0 / this->size();
    is_dirty = false;
}

demo2.cpp

#include <iostream>
#include <string>
#include "GradeCalc.hpp"
void test() {
    GradeCalc c1("OOP");

    std::cout << "录入成绩:\n";
    c1.input(5);
    
    std::cout << "输出成绩:\n";
    c1.output();
    
    std::cout << "排序后成绩:\n";
    c1.sort(); c1.output();
    
    std::cout << "*************成绩统计信息*************\n";
    c1.info();
}
int main() {
    test();
}

 运行结果

 回答问题：

 

 

task3

Graph.hpp

#pragma once

#include<string>
#include<vector>

enum class GraphType{circle,triangle,rectangle};

//Grape类定义
class Graph{
public:
    virtual void draw(){};
    virtual ~Graph()=default;
};

//Circle类
class Circle:public Graph{
public:
    void draw();
};

//Triangle类
class Triangle:public Graph{
public: 
    void draw();
};

//Rectangle类
class Rectangle:public Graph{
public:
    void draw();
};

//Canvas （画布）
class Canvas{
public:
    void add(const std::string &type);
    void paint() const;
    ~Canvas();
private:
    std::vector<Graph*> graphs;
};

//工具函数
GraphType str_to_GraphType(const std::string &s); //string->enum
Graph* make_graph(const std::string &type); //创建图形，返回堆对象指针

Graph.cpp

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

#include"Graph.hpp"

void Circle::draw(){ std::cout<<"draw a circle...\n"; }

void Triangle::draw(){ std::cout<<"draw a triangle...\n"; }

void Rectangle::draw(){ std::cout<<"draw a rectangle...\n"; }

void Canvas::add(const std::string &type){
    Graph* g=make_graph(type);
    if(g)
        graphs.push_back(g);
}

void Canvas::paint() const{
    for(Graph *g:graphs)
        g->draw();
}

Canvas::~Canvas(){
    for(Graph* g:graphs)
        delete g;
}

//工具函数实现，字符串->枚举转换
GraphType str_to_GraphType(const std::string &s){
    std::string t=s;
    std::transform(s.begin(),s.end(),t.begin(),[](unsigned char c){ return std::tolower(c); });
    if(t=="circle") return GraphType::circle;
    if(t=="triangle") return GraphType::triangle;
    if(t=="rectangle") return GraphType::rectangle;
    return GraphType::circle;  //缺省返回
}

//创建图形，返回堆对象指针
Graph* make_graph(const std::string& type){
    switch(str_to_GraphType(type)){
        case GraphType::circle: return new Circle;
        case GraphType::triangle: return new Triangle;
        case GraphType::rectangle: return new Rectangle;
        default: return nullptr;
    }
}

 demo3.cpp

#include <string>
#include "Graph.hpp"
void test() {
    Canvas canvas;
    canvas.add("circle");
    canvas.add("triangle");
    canvas.add("rectangle");
    canvas.paint();
}
int main() {
    test();
}

运行结果

 回答问题：

 

 

task4

问题场景描述：
模拟设计了一个玩具工厂，ToyFactory 类可以：向工厂添加任意数量、任意类型的玩具(add());查看工厂支持的所有玩具类别及其功能特点(info());指挥工厂内所有已生产的玩具同时进行技能表演(play)。
main函数：在main函数中输入玩具的类型，生产出了四种不同功能的毛绒玩具：会跳舞的小熊、可遥控行驶的小车、会播放多首歌曲的音乐盒、以及会前后弹跳的玩具青蛙。每种玩具都具备独特的play_skill，且对外提供统一的玩具接口(play_skill)。

各类之间的关系（继承、组合等）及设计理由：
Toy是所有玩具类的基类，Bear,Remote_car,Music_box,Frog都继承了Toy类，是is-a关系，且四个子类都重写了Toy当中的虚函数play_skill()（其实这里的play_skill感觉直接用纯虚函数写更合适），在这个函数中调用了他们各自的skill，play_skill作为对外的公共接口用于在ToyFactory类中调用以展示技能，ToyFactory类中用到了组合类，体现的是has-a的关系，std::vector<Toy*> toys;，组合一个vector类用于存储玩具对象，std::vector<std::pair<std::string, std::string>>还有一个用于存储玩具工厂所包含的玩具类型以及对应的功能。

Toy.hpp

#pragma once
#include<iostream>
#include<algorithm>
#include<string>

enum class Toys_name{Bear,Remote_car,Music_box,Frog,Unknown};

class Toy{
public:
    Toy(const std::string& name,const std::string &type,const std::string skill);
    virtual void play_skill(){}
    virtual ~Toy()=default;
    std::string get_name(){ return toy_name; }
    std::string get_type(){ return toy_type; }
    std::string get_skill(){ return toy_skill; }
protected:
    std::string toy_name;
    std::string toy_type;
    std::string toy_skill;
};

//会跳舞的小熊
class Bear:public Toy{
public:
    Bear(const std::string& name);
    void dance_a();
    void dance_b();
    void play_skill();
};

//遥控毛绒小车
class Remote_car:public Toy{
public:
    Remote_car(const std::string& name,int r);
    void move(bool dir);
    void play_skill();
private:
    int rate; //车速
    bool stop=true; //判断小车此时是否为静止状态
};

//毛绒音乐盒
class Music_box:public Toy{
public:
    Music_box(const std::string& name,int num);
    void play_skill();
private:
    int song_num; //歌曲数量
};

//可弹跳的青蛙
class Frog:public Toy{
public:
    Frog(const std::string& name);
    void jump(bool dir);    
    void play_skill();
private:
    bool stop=true;
};

//将string->enum
Toys_name str_to_enum(const std::string& s);

Toy* make_toys(const std::string &s);

Toy.cpp

#include<iostream>
#include<string>
#include<algorithm>

#include"Toy.hpp"

Toy::Toy(const std::string& name,const std::string &type,const std::string skill):toy_name(name),toy_type(type),toy_skill(skill){}
Bear::Bear(const std::string& name):Toy(name,"动物类玩具","跳舞"){}
void Bear::dance_a(){ std::cout<<"小熊开始跳舞蹈A...\n"; }
void Bear::dance_b(){ std::cout<<"小熊开始跳舞蹈B...\n"; }
void Bear::play_skill(){
    dance_a();
    dance_b();
}

Remote_car::Remote_car(const std::string& name,int r):Toy(name,"遥控类玩具","行驶"),rate{r}{}
void Remote_car::move(bool dir){ //dir为true时前进，反之后退
    if(stop) return;
    if(dir) std::cout<<"小车正在以"<<rate<<"m/s"<<"的速度向前移动\n";
    else std::cout<<"小车正在以"<<rate<<"m/s"<<"的速度向后移动\n";
}
void Remote_car::play_skill(){
    stop=false;
    move(true);
    move(false);
    stop=false;
    std::cout<<"小车停止移动...\n";
}

Music_box::Music_box(const std::string& name,int num):Toy(name,"发声类玩具","放音乐"),song_num{num}{}
void Music_box::play_skill(){
    std::cout<<"音乐盒共有"<<song_num<<"首歌，开始播放歌曲...\n";
    for(int i=1;i<=song_num;i++){
        std::cout<<"正在播放歌曲"<<i<<"\n";
    }
}

Frog::Frog(const std::string& name):Toy(name,"动作类玩具类","弹跳"){}
void Frog::jump(bool dir){ //dir为true向前跳，反之向后跳
    if(stop) return;
    if(dir) std::cout<<"小青蛙向前跳\n";
    else std::cout<<"小青蛙向后跳\n";
}
void Frog::play_skill(){
    stop=false;
    jump(true);
    jump(false);
    stop=false;
    std::cout<<"小青蛙停止跳跃...";
}

//将string->enum
Toys_name str_to_enum(const std::string& s){   
    std::string t=s;
    std::transform(s.begin(),s.end(),t.begin(),[](unsigned char c){ return std::tolower(c); });
    if(t=="bear") return Toys_name::Bear;
    if(t=="music_box") return Toys_name::Music_box;
    if(t=="frog") return Toys_name::Frog;
    if(t=="remote_car") return Toys_name::Remote_car;
    return Toys_name::Unknown; //缺省返回
}

Toy* make_toys(const std::string& s){
    switch(str_to_enum(s)){
        case Toys_name::Bear: return new Bear("小熊"); 
        case Toys_name::Remote_car: return new Remote_car("遥控小车", 5); 
        case Toys_name::Music_box: return new Music_box("音乐盒", 3); 
        case Toys_name::Frog: return new Frog("小青蛙"); 
        case Toys_name::Unknown:
        default:
            std::cout << "错误：无法根据枚举值创建玩具。" << std::endl;
            return nullptr;
    }
}

ToyFactory.hpp

#pragma once
#include<string>
#include<vector>
#include<utility>

#include"Toy.hpp"

class ToyFactory{
public:
    void info() const;
    void play() const;
    void add(const std::string &type);
    ~ToyFactory();

private:
    std::vector<Toy*> toys;
    std::vector<std::pair<std::string, std::string>> toy_categories={
        {"动物类玩具", "模拟动物形态/行为"},
        {"发声类玩具", "能播放音乐/模拟声音"},
        {"动作类玩具", "能完成特定动作"},
        {"遥控类玩具", "远程操控移动/动作"}
    }; //玩具工厂所包含的玩具类型以及对应的功能
};

ToyFactory.cpp

#include<vector>

#include"ToyFactory.hpp"
#include"Toy.hpp"

void ToyFactory::add(const std::string &type){
    Toy *t=make_toys(type);
    if(t) toys.push_back(t);
}

void ToyFactory::play() const{
    for(Toy *t:toys){
        std::cout<<"玩具名称:"<<t->get_name()<<" 玩具类型:"<<t->get_type()<<" 玩具技能:"<<t->get_skill();
        std::cout<<"\nshow skill: \n";
        t->play_skill();
        std::cout<<"\n";
    }
}

void ToyFactory::info() const{
    std::cout<<"玩具工厂生产的四种玩具极其特点："<<"\n";
    for(int i=0;i<toy_categories.size();i++){
        std::cout<<i+1<<" "<<toy_categories[i].first<<":"<<toy_categories[i].second<<std::endl;
    }
    std::cout<<"\n";
    std::cout<<"展示玩具技能："<<"\n";
    play();
}

ToyFactory::~ToyFactory(){
    for(auto t:toys) delete t;
}

demo4.cpp

#include<iostream>
#include"Toy.hpp"
#include"ToyFactory.hpp"

int main(){
    ToyFactory t;
    t.add("Bear");
    t.add("Music_box");
    t.add("Remote_car"); 
    t.add("Frog");
    t.info();
}

运行结果