实验4

1.实验任务一 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 << "无效输入! 人数不能为负数\n";
        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 = static_cast<int>(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];        // [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(size_t 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();
}

运行结果如下

 

问题1：std::vector<int> grades   功能是形成一个装任意多个成绩的动态列表     

             std::array<int, 5> counts    功能是存5个分数段人数

             std::array<double, 5> rates    功能是存5个分数段占比

问题2：我觉得不合法，因为push_back是std::vector这个类的函数，而std::vector<int> grades是GradeCalc类的私有成员，所以在GradeCalc类的外部无法使用这个函数，所以不合法

问题3：(1)会被调用1次，是在执行c1.info的时候，is_dirty为true的时候，调用了一次，调用后，is_dirty变为false，就不调用了。

                 is_dirty 作用是设置脏标记，当它是true的时候说明成绩信息有变更，要重新统计一次，为false就没有变更

             (2)我觉得不用改位置，只要在update_grade函数末尾把is_dirty置为true就行

问题4：中位数是在排好的数据里面找中间位置的，所以我觉得在sort里面加

void GradeCalc::sort(bool ascending) {
   if(ascending)
          std::sort(grades.begin(), grades.end());
   else
          std::sort(grades.begin(), grades.end(), std::greater<int>()); //降序
   double mid;
   size_t n=grades.size();
   if(n%2==0){
           mid=(grades[n/2]+grades[n/2+1])/2;
    }
    else{
            mid=grades[n/2];
     }
      std::cout<<"中位数是："<<mid;

}

问题5：我觉得不能去掉，当数据更改的时候，没有这两行会出错。因为在第一次调用compute的时候存了不同分数段的人数，当数据变更，要重新统计的时候，没有这两行把人数清零，就会在第一次统计的基础上去继续统计，统计结果就会出错

问题6：(1)功能没有影响，去掉后运行结果如下

 

(2)在性能上应该有影响。reverse的功能是提前预订好大空间，不会频繁出现内存不够的情况，如果去掉，当数据很多的时候，就要频繁的重新分配内存，移动数据

2.实验任务二

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;                          // 返回最低分
    int max() const;                          // 返回最高分
    double average() const;                   // 返回平均分
    void info();                              // 输出成绩统计信息

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

private:
    std::string course_name;     // 课程名
    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 grade: *this)
        std::cout << grade << ' ';
    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 = static_cast<int>(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(size_t 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();
}

运行结果如下

 

问题1：class GradeCalc: private std::vector<int>

问题2：不会。当前继承方式下，基类 vector<int> 的接口不会自动成为 GradeCalc 的接口，因为基类是以私有继承的方式继承过来的，在GradeCalc类里，它属于私有，无法自动成为接口。

             我觉得无法编译通过。因为push_back是基类 vector<int>的成员函数，基类以私有方式继承过来，在类的外部无法访问，因此会报错

问题3：组合类是通过私有成员grades来访问数据，但因为grades是私有成员，在类的外部无法直接访问，只能通过一些共有接口比如output等来间接访问。而继承是通过当前的这个对象自己来访问数据，因为继承就相当于这个对象本身是vector类型，所以在类内部，可以直接通过自己访问数据，但因为继承方式是私有继承，所以在类外部还是只能通过一些共有接口访问。

问题4：我觉得组合类更适合。首先是我觉得组合类在编写过程中逻辑很清晰，很分明，就是形成一个装任意多个成绩的动态列表，然后使用它，对它进行排序，找最值，而继承是本身是一个容器列表，在理解上有些奇怪，会让思路逻辑没那么清晰。其次我觉得组合类灵活性更强一点，如果不需要用vector了，直接把私有成员类型替换一下，然后操作修改一下就行，但是继承可能就要去掉继承，然后类里面还要重新添加成员，把原先的this指针进行替换

 

3.实验任务三

Graph.hpp 代码如下

#pragma once

#include <string>
#include <vector>

enum class GraphType {circle, triangle, rectangle};

// Graph类定义
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;
};

// 4. 工具函数
GraphType str_to_GraphType(const std::string& s);  // 字符串转枚举类型
Graph* make_graph(const std::string& type);  // 创建图形，返回堆对象指针

Graph.cpp代码如下

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

#include "Graph.hpp"

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

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

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

// Canvas类实现
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();
}

运行结果如下

问题1：(1)std::vector<Graph*> graphs;   功能是存放Graph指针的动态数组

             (2)class Circle : public Graph     ;     class Triangle : public Graph     ;      class Rectangle : public Graph    ;     

                

问题2：(1)若没有声明为虚函数，运行结果如下，无运行结果。因为没有声明为虚函数，那么g->draw()就是指向基类的draw函数，基类的draw函数没有执行语句，所以没有输出

(2)如果改为std::vector<Graph>之后，存储的都是Graph类型的数据，那么派生类存入进去的时候，只会保留属于Graph的特点，而自身的draw功能没有被保存，所以最后调用draw的时候，调用的都是基类的draw函数，派生类的draw功能无法实现

(3)如果没有声明为虚函数，会内存泄漏，因为如果析构函数不是虚函数。每次调用的都是基类的析构函数，派生类对象的资源没有得到释放

问题3：首先是在强枚举里面加入star，然后是在Graph.hpp里面加入star类的声明，class Circle : public Graph...，在Graph.cpp里面加入star类的实现void Star::draw()  { std::cout << "draw a star...\n"; }，在GraphType str_to_GraphType(const std::string& s)里面加入star的字符串枚举转换，最后在Graph* make_graph(const std::string& type)中，加入case GraphType::star:  return new Star;

问题4：(1)在Canvas的析构函数里面一一被释放

             (2)利：非常简单方便，可以直接创建对象和释放资源

                  弊：很有可能会误操作，比如忘记释放资源，或者在修改数据之前就把旧数据删除了等等，比较危险

 4.实验任务4

应用的问题描述：这是玩具工厂对不同类型的玩具的管理系统，工厂需要创造不同类型的玩具（音乐类，故事类，算术类等），每种玩具都有基本属性比如名称，材质，适用年龄，以及特别的功能，系统统一管理玩具的创造，存储，信息展示等。

各类之间的关系及设计理由：StoryToy，SingToy，PinyinToy，MathToy都是基类Toy的派生类，因为这些派生类玩具都是Toy类玩具，是is-a的关系，同时每个种类玩具都有自己特别的功能，具有多态性，所有选用继承；‘

ToyFactory和vector类组合，因为我觉得玩具工厂与动态容器，是玩具工厂拥有一个装玩具的动态容器进行存储管理，而不是玩具工厂是一种容器，他们之间是has-a的关系，因此，选用了组合

然后仿照实验三任务，选用了指针进行管理。

 

Toy.h代码如下

#include<string>
#include<iostream>

using namespace std;
class Toy{
    protected:
        string name;
        string type;
        string material;
        float price;
        string agerange;
    public:
        Toy(string n,string t,string m,float p,string age):name(n),type(t),material(m),price(p),agerange(age){}
        virtual void Fuction()=0;
        string get_name(){return name;}
        string get_type(){return type;}
        string get_material(){return material;}
        float get_price(){return price;}
        string get_agerange(){return agerange;}
        virtual ~Toy()=default;
};

class StoryToy:public Toy{
    private:
        string storyname;
    public:
        StoryToy(string n,string t,string m,float p,string age,string stn):Toy(n,t,m,p,age),storyname(stn){}
        void Fuction(){
            cout<<"【"<<name<<"】"<<"正在讲"<<"《"<<storyname<<"》的故事哦~"<<endl;
        }
};

class SingToy:public Toy{
    private:
        string songname;
    public:
        SingToy(string n,string t,string m,float p,string age,string soname):Toy(n,t,m,p,age),songname(soname){}
        void Fuction(){
            cout<<"【"<<name<<"】"<<"正在唱"<<"《"<<songname<<"》歌曲哦~"<<endl;
        }
};



class PinyinToy:public Toy{
    private:
        string pinyin;
    public:
        PinyinToy(string n,string t,string m,float p,string age,string py):Toy(n,t,m,p,age),pinyin(py){}
        void Fuction(){
            cout<<"【"<<name<<"】"<<"教拼音："<<pinyin<<"跟我读哦~"<<endl;
        }
};

class MathToy:public Toy{
    private:
        int num1,num2;
        char operate;
    public:
        MathToy(string n,string t,string m,float p,string age,int n1,int n2,char op):Toy(n,t,m,p,age),num1(n1),num2(n2),operate(op){}
        void Fuction(){
            cout<<"【"<<name<<"】"<<"正在运算:"<<num1<<operate<<num2<<"=";
            switch(operate){
                case '+':cout<<num1+num2;break;
                case '-':cout<<num1-num2;break;
                case '*':cout<<num1*num2;break;
                case '/':
                    if(num2==0){
                        cout<<"不能运算哦，除数不能是零";
                    }else{
                        cout<<num1/num2;
                    }
                    break;
                default: cout<<"没有这种运算符";
            }
            cout<<endl;
        }
};

ToyFactory.h代码如下

#include"ToyFactory.h"
#include<iostream>
using namespace std;
void ToyFactory::addToy(Toy* toy){
    if(toy!=nullptr){
        ToyList.push_back(toy);
    }
}

void ToyFactory::showalltoys(){
    std::cout<<"\n=====玩具工厂产品清单=====\n";
    for(size_t i=0;i<ToyList.size();i++){
        cout<<"["<<i+1<<"]"<<"产品信息："<<endl
        <<"名称："<<ToyList[i]->get_name()<<endl
        <<"类型："<<ToyList[i]->get_type()<<endl
        <<"材质："<<ToyList[i]->get_material()<<endl
        <<"价格："<<ToyList[i]->get_price()<<"元"<<endl
        <<"适用年龄："<<ToyList[i]->get_agerange()<<"岁"<<endl
        <<"功能：";
        ToyList[i]->Fuction();
        cout<<"------------------------\n";
    }

}

void ToyFactory::createToy(const string& name,const string& toytype,const string& material,float price,const string& agerange,const string& func,int num1,int num2,char op){
    Toy* toy=nullptr;
    if(toytype=="story"){
        toy=new StoryToy(name,"故事类",material,price,agerange,func);
    }else if(toytype=="sing"){
        toy=new SingToy(name,"唱歌类",material,price,agerange,func);
    }else if(toytype=="pinyin"){
        toy=new PinyinToy(name,"拼音类",material,price,agerange,func);
    }else if(toytype=="math"){
        toy=new MathToy(name,"算数类",material,price,agerange,num1,num2,op);
    }else{
        cout<<"暂无该类型玩具"<<endl;
        return;
    }
    addToy(toy);
}

ToyFactory::~ToyFactory(){
    for(Toy* toy:ToyList){
        delete toy;
    }
    ToyList.clear();
}

test代码如下

#include "ToyFactory.h"
int main(){
    ToyFactory factory;
    factory.createToy("读绘本的小熊","story","棉布",89.9,"4~7","白雪公主");
    factory.createToy("会唱歌的小鸟","sing","毛绒",69.9,"3~6","ABCD单词歌");
    factory.createToy("教拼音的鹦鹉","pinyin","软胶",169.9,"7~12","a、o、e");
    factory.createToy("会算数的小猴子","math","毛绒",199.9,"7~13","",3,4,'+');
    factory.showalltoys() ;
    return 0;
}

运行结果如下