实验4

1. 实验任务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;  // 更新脏标记
}

 

task1.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::string course_name;：存储课程名称，标识当前成绩计算器所属课程。

std::vector<int> grades;：存储课程的所有成绩数据，是成绩计算的核心数据载体。

std::array<int, 5> counts;：存储 5 个分数段的人数统计结果。

std::array<double, 5> rates;：存储 5 个分数段的人数占比统计结果。

 问题2：

不合法

push_back 是 vector<int> 的成员函数，grades 是 GradeCalc 的私有成员，外部无法直接访问，GradeCalc 未暴露该接口

问题3：

(1) compute 仅被调用 1 次；is_dirty 用于标记成绩数据是否变更，仅当数据变更时才重新执行 compute 统计，避免重复计算，提升效率。

(2) 不需要；新增 update_grade 时只需设置 is_dirty=true，调用时会自动触发 compute，无需修改 compute 调用位置。

问题4：

 无需新增数据成员，在 average() 函数同级新增 median() 成员函数，利用已有 grades 数据计算中位数

double GradeCalc::median() const {
    if (grades.empty())
        return 0.0;
    std::vector<int> temp = grades;
    std::sort(temp.begin(), temp.end());
    int size = temp.size();
    if (size % 2 == 1) {
        return temp[size / 2];
    } else {
        return (temp[size / 2 - 1] + temp[size / 2]) / 2.0;
    }
}

问题5：

不能去掉。若去掉，当成绩数据发生多次变更，counts 和 rates 会保留上一次的统计结果，新的统计数据会与旧数据叠加，导致统计结果错误。

问题6：

1.对程序功能无影响。reserve(n) 的作用是预分配 n 个元素的内存空间，不影响元素的插入、访问和排序等核心功能，去掉后程序仍能正常运行。

2.对性能有影响：当录入大量成绩时，去掉 reserve(n) 会导致 std::vector 频繁触发内存重新分配和数据拷贝，增加内存开销和时间开销，降低程序运行效率。

 

2. 实验任务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;
}

task2.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：

1.不会自动成为GradeCalc的接口。

2.不能编译通过。原因：GradeCalc采用私有继承std::vector<int>，基类的所有成员在派生类外部不可见，GradeCalc未提供push_back的公有接口

问题3：

组合方式：通过私有成员对象直接访问数据。

继承方式：通过派生类自身访问数据。

组合方式通过成员对象隔离基类接口，外部完全无法访问成员对象的原生接口，封装性更强；私有继承方式虽也隐藏基类接口，但派生类自身与基类耦合更紧密，本质是 “is-a” 关系的隐式依赖，而组合是 “has-a” 的显式关联。

问题4：

组合方案更适合成绩计算场景。

1.语义匹配：成绩计算器与成绩存储容器是 “包含” 关系，而非 “是” 关系，组合更符合语义逻辑。

2.封装性更强：组合方式中std::vector<int>是私有成员，外部无法直接操作容器，仅能通过GradeCalc提供的接口交互，避免误操作容器导致的数据异常；私有继承虽也隐藏接口，但派生类与基类耦合度高，若基类接口变更，派生类可能受影响。

3.扩展性更优：若后续需替换成绩存储容器，组合方式仅需修改GradeCalc内部成员和相关实现，外部接口无需变更；继承方式则需修改继承关系，改动范围更大。

 

3. 实验任务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;
    }
}

task3.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;

被组合对象的功能：存储和管理所有图形对象的指针

2.

Graph.hpp 中体现继承关系的类声明代码行共 3 处，分别为：

class Circle : public Graph {

class Triangle : public Graph {

class Rectangle : public Graph {

问题2：

1.

Canvas::paint()中g->draw()将始终调用Graph基类的draw函数，运行结果会全部输出空的draw信息，不会调用子类的具体信息进行绘制

2.

存储派生对象时会导致派生部分无法存入

3.

派生类中分配的资源无法正确释放，导致内存泄漏

问题3：

Graph.hpp

在GraphType枚举中添加star枚举值

新增Star类声明，继承自Graph

Graph.cpp

在str_to_GraphType函数中添加star的判断逻辑

在make_graph函数中添加GraphType::star的分支

实现Star类的draw函数

问题4：

1.

canvas析构函数

2.

优点：灵活性高，性能开销低

缺点：易出现内存问题，可读性和维护性差

 

4. 实验任务4

Toy.hpp

#pragma once
#include <string>
#include <vector>
using namespace std;

class Toy {
public:
    Toy(const string& toyName, const string& toyType);
    virtual void showToyInfoWithFunction() const = 0;
    virtual ~Toy() = default;

protected:
    string name; 
    string type; 
};

class PoetryDramaFigure : public Toy {
public:
    PoetryDramaFigure(const string& toyName, const string& toyType, const string& funcDesc);
    void showToyInfoWithFunction() const override;

private:
    string specialFunc; 
};

class KunInteractiveDoll : public Toy {
public:
    KunInteractiveDoll(const string& toyName, const string& toyType, const string& funcDesc);
    void showToyInfoWithFunction() const override;

private:
    string specialFunc;
};

class DingdongChickenPillow : public Toy {
public:
    DingdongChickenPillow(const string& toyName, const string& toyType, const string& funcDesc);
    void showToyInfoWithFunction() const override;

private:
    string specialFunc; 
};

class ToyFactory {
public:
    ~ToyFactory();
    void addToy(Toy* toy); 
    void showAllToysWithFunctions() const; 

private:
    vector<Toy*> toyList; 
};

 Toy.cpp

#include <iostream>
#include "Toy.hpp"
using namespace std;

Toy::Toy(const string& toyName, const string& toyType) 
    : name(toyName), type(toyType) {}

PoetryDramaFigure::PoetryDramaFigure(const string& toyName, const string& toyType, const string& funcDesc)
    : Toy(toyName, toyType), specialFunc(funcDesc) {}

void PoetryDramaFigure::showToyInfoWithFunction() const {
    cout << "【玩具基础信息】" << endl;
    cout << "名称：" << name << " | 类型：" << type << " | 特异功能：" << specialFunc << endl;
    cout << "【特异功能效果】"  << " 播放音乐：哈基米～南北绿豆～" << endl;
    cout << "----------------------------------------" << endl;
}

KunInteractiveDoll::KunInteractiveDoll(const string& toyName, const string& toyType, const string& funcDesc)
    : Toy(toyName, toyType), specialFunc(funcDesc) {}

void KunInteractiveDoll::showToyInfoWithFunction() const {
    cout << "【玩具基础信息】" << endl;
    cout << "名称：" << name << " | 类型：" << type << " | 特异功能：" << specialFunc << endl;
    cout << "【特异功能效果】"  << " 鸡你太美～（铁山靠）" << endl;
    cout << "----------------------------------------" << endl;
}

DingdongChickenPillow::DingdongChickenPillow(const string& toyName, const string& toyType, const string& funcDesc)
    : Toy(toyName, toyType), specialFunc(funcDesc) {}

void DingdongChickenPillow::showToyInfoWithFunction() const {
    cout << "【玩具基础信息】" << endl;
    cout << "名称：" << name << " | 类型：" << type << " | 特异功能：" << specialFunc << endl;
    cout << "【特异功能效果】"  << " 叮咚鸡！大狗叫！" << endl;
    cout << "----------------------------------------" << endl;
}

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

void ToyFactory::addToy(Toy* toy) {
    if (toy != nullptr) {
        toyList.push_back(toy);
    }
}

void ToyFactory::showAllToysWithFunctions() const {
    cout << "\n===== 定制玩具工厂完整信息 =====\n" << endl;
    if (toyList.empty()) {
        cout << "工厂暂无定制玩具！" << endl;
        return;
    }
    for (size_t i = 0; i < toyList.size(); ++i) {
        cout << "[" << i + 1 << "] 玩具详情：" << endl;
        toyList[i]->showToyInfoWithFunction();
    }
}

 

demo4.cpp

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

int main() {
    ToyFactory customToyFactory;

    customToyFactory.addToy(new PoetryDramaFigure("诗歌剧", "手办", "唱哈基米音乐"));
    customToyFactory.addToy(new KunInteractiveDoll("坤坤", "互动玩偶", "唱跳rap篮球"));
    customToyFactory.addToy(new DingdongChickenPillow("叮咚鸡", "玩具抱枕", "叮咚鸡大狗叫"));

    customToyFactory.showAllToysWithFunctions();

    return 0;
}

 

运行结果

 

 1.继承关系

Toy与每个单独的玩具，复用基类的通用属性与接口，同时实现自身特有的功能逻辑

 2.组合关系

 ToyFactory与Toy，存储多个Toy类的指针，实现对多款玩具的集中管理