实验四

任务一:

GradeCalc.hpp

#pragma once
#include<vector>
#include<array>
#include<string>
class GradeCalc{
    public:
        GradeCalc(const std::string &cname);
        void intput(int 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::vector<int> grades;
        std::array<int,5> counts;
        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];     
        else if (grade < 70)
            ++counts[1];        
        else if (grade < 80)
            ++counts[2];        
        else if (grade < 90)
            ++counts[3];        
        else
            ++counts[4];        
    }
    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();
}

结果:

image

 

Q1:

std::vector<int>grades    动态存储学生成绩

std::array<int,5>couts            统计人数

std::array<double,5>rates    统计5个分段的百分比

Q2:

不合法,外部代码不应该直接作用于内部代码

Q3:

1.调用1次,is_dirty标记数据避免重复使用

2.无需更改compute的调用位置

Q4:

在GradeCalc.hpp中增加:

private:
    double median_grade;
public:
    double median()const;

在GradeCalc.cpp增加:

if (!grades.empty()){
    std::vector<int>temp=grades;
    std::sort(temp.begin(),temp.end());
    if(temp.size()%2==1)
    {
        median_grade=temp[temp.size()/2];
    }else
    {
        median_grade=(temp[temp.size()/2-1]+temp[temp.size()/2])/2;
    }
    is_dirty=false;
}

Q5:

不能去掉,若去掉调用compute()会将新的结果加到旧的结果上

Q6:

去掉grades.reserve(n)对程序没有影响

性能影响:去掉vector会增加内存的大小

任务二:

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);                       
    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;   
    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();
}

result:

image

 Q1:

class GradeCalc: private std::vector<int> {

Q2:

不能编译通过,因为该继承是私有继承,基类中的所有公有成员都会变成私有无法直接访问。

Q3;

组合方式:只能通过GradeCalc提供的接口访问数据

继承方式:在类的内部可以直接访问

Q4:

组合方案更好一点;1.组合方案能通过GradeCalc的接口直接访问,2.符合优先使用组合的原则

 

任务3;

Graph.hpp:

#pragma once
#include<string>
#include<vector>
enum class GraphType{circle,triangle,rectangle};
class Graph{
    public:
        virtual void draw(){}
        virtual ~Graph()=default; 
};
class Circle : public Graph{
    public:
        void draw();
};
class Triangle: public Graph{
    public:
        void draw();
};
class Rectangle: public Graph{
    public:
        void draw();
};
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);
Graph* make_graph(const std::string& type);

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();
}

result:

image

 Q1:

1.

std::vector<Graph*>graphs;
用于存储Graph对象指针

2.

class Circle : public Graph{
    public:
        void draw();
};
class Triangle: public Graph{
    public:
        void draw();
};
class Rectangle: public Graph{
    public:
        void draw();
};
问题2:
1.若不使用虚函数则每次调用draw()都会调用Graph基类中draw()的方法
2.无法使用Graph中子类的属性
3.若不是虚函数则子类的析构函数不会被调用。
问题3:
enum class GraphType{circle,triangle,rectangle,star};
声明Star类:
class Star:public Graph{
public:
void draw();
}
实现Star::draw()
void star::draw(){std<<cout"draw a star...\n"}
str_to_GraphType:
if(t=="Star")return GraphType::star
再增加一个case:
case GraphType::star: return new star
问题4:
1.在析构函数中被释放
2.重复使用同一指针会导致无法确定哪个指针指向不明

任务四:
#ifndef TOY_HPP
#define TOY_HPP

#include <string>
#include <memory>
#include <vector>

class Toy {
public:
    virtual ~Toy() = default;
    virtual void show() const = 0;
    virtual void action() const = 0;
};

class ElectronicToy : public Toy {
public:
    ElectronicToy(const std::string& name);
    void show() const override;
    void action() const override;
private:
    std::string name;
};

class StuffedToy : public Toy {
public:
    StuffedToy(const std::string& name);
    void show() const override;
    void action() const override;
private:
    std::string name;
};

class ToyFactory {
public:
    void add(std::unique_ptr<Toy> toy);
    void display() const;
private:
    std::vector<std::unique_ptr<Toy>> toys;
};

toy.cpp

#include "toy.hpp"
#include <iostream>
#include <memory>

int main() {
    ToyFactory factory;
    
    factory.add(std::make_unique<ElectronicToy>("音乐熊"));
    factory.add(std::make_unique<StuffedToy>("泰迪熊"));
    factory.add(std::make_unique<ElectronicToy>("机器人"));
    
    factory.display();
    
    return 0;
}

demo4:

#include <iostream>
#include <memory>
#include<toy.hpp>
int main() {
    ToyFactory factory;
    
 
    factory.add(std::unique_ptr<Toy>(new ElectronicToy("音乐熊")));
    factory.add(std::unique_ptr<Toy>(new StuffedToy("泰迪熊")));
    factory.add(std::unique_ptr<Toy>(new ElectronicToy("机器人")));
    
    factory.display();
    
    return 0;
}

result:

image

 

posted @ 2025-12-02 14:40  愛過  阅读(0)  评论(0)    收藏  举报