实验四

实验任务一：
源代码：

#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;      // 脏标记，记录是否成绩信息有变更
};

#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;  // 更新脏标记
}

#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：组合关系识别：

GradeCalc 类声明中，逐行写出所有体现"组合"关系的成员声明，并用一句话说明每个被组合对象的功能。

答：

std::string course_name;：存储课程名称。

std::vector<int> grades;：存储课程的所有成绩数据。

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

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

 

问题2：接口暴露理解

如在 test 模块中这样使用，是否合法？如不合法，解释原因。

答：

不合法，push_back是vector<int>的成员方法，而grades是GradeCalc的私有成员，组合方式下外部无法直接调用。

 

问题3：架构设计分析

当前设计方案中， compute 在 info 模块中调用：

（1）连续打印3次统计信息， compute 会被调用几次？标记 is_dirty 起到什么作用？

答：

compute 会被调用 1 次。is_dirty标记用于记录成绩数据是否发生变更，仅当数据变更时才重新计算统计信息，避免重复计算。

（2）如新增 update_grade(index, new_grade) ,这种设计需要更改 compute 调用位置吗？简洁说明理由。

答：

不需要。新增update_grade方法时，只需在方法内设置is_dirty = true，即可触发info方法中自动调用compute重新计算，无需修改compute调用位置。

 

问题4：功能扩展设计

要增加"中位数"统计，不新增数据成员怎么做？在哪个函数里加？写出伪代码。

答：

直接在Info中实现，伪代码如下：

void GradeCalc::info() {
    // 原来的：成绩变了就重新算统计
    if (is_dirty) compute();

    // 原来的：输出课程名、平均分、最高分、最低分
    输出课程名、平均分、最高分、最低分;

    // 新增：算中位数并输出
    成绩总数 = grades的个数;
    if (成绩总数 == 0) {
        输出 "中位数:\t0.00";
    } else if (成绩总数是奇数) {
        输出 "中位数:\t" + grades[成绩总数/2];  // 中间数
    } else {
        // 中间两个数的平均
        输出 "中位数:\t" + (grades[成绩总数/2-1] + grades[成绩总数/2])/2.0;
    }

    // 原来的：输出分数段统计
    输出各分数段人数和占比;
}

 

问题5：数据状态管理

GradeCalc 和 compute 中都包含代码： counts.fill(0); rates.fill(0); 。

compute 中能否去掉这两行？如去掉，在哪种使用场景下会引发统计错误？

答：

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

 

问题6：内存管理理解

input 模块中代码 grades.reserve(n); 如果去掉：

（1）对程序功能有影响吗？（去掉重新编译、运行，观察功能是否受影响）

答：

无影响

（2）对性能有影响吗？如有影响，用一句话陈述具体影响。

答：

会影响性能，当录入大量成绩时，vector需频繁扩容，导致程序运行效率降低。

 

实验任务二：
源代码：

#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;      // 脏标记，记录是否成绩信息有变更
};

#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;
}

#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：继承关系识别

写出 GradeCalc 类声明体现"继承"关系的完整代码行。

答：
class GradeCalc: private std::vector<int>

问题2：接口暴露理解

当前继承方式下，基类 vector<int> 的接口会自动成为 GradeCalc 的接口吗？

如在 test 模块中这样用，能否编译通过？用一句话解释原因。

答：

不会自动成为 GradeCalc 的接口；不能编译通过。采用私有继承方式，vector<int>的公有接口会被隐藏，外部无法直接调用。

问题3：数据访问差异

对比继承方式与组合方式内部实现数据访问的一行典型代码。说明两种方式下的封装差异带来的数据访问接口差异。

答：
组合方式：通过私有成员变量直接访问数据，封装性强，外部无法直接操作数据。

继承方式：通过派生类对象本身访问基类数据，本质是直接使用基类的迭代器接口，封装性较弱，内部可直接调用基类方法。

 

问题4：组合 vs. 继承方案选择

你认为组合方案和继承方案，哪个更适合成绩计算这个问题场景？简洁陈述你的结论和理由。

答：

组合方案更适合。成绩计算器与成绩集合是 "has-a" 关系（计算器包含成绩集合），组合方式封装性更强，可避免基类接口暴露带来的误用风险，且后续扩展时灵活性更高。

实验任务三：
源代码：

#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);  // 创建图形，返回堆对象指针

#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;
    }
}

#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）写出Graph.hpp中体现"组合"关系的成员声明代码行，并用一句话说明被组合对象的功能。

答：

std::vector<Graph*> graphs;：存储多个图形对象的指针。

（2）写出Graph.hpp中体现"继承"关系的类声明代码行。

答：

class Circle : public Graph

class Triangle : public Graph

class Rectangle : public Graph

 

问题2：多态机制观察

（1） Graph 中的 draw 若未声明成虚函数， Canvas::paint() 中 g->draw() 运行结果会有何不同？

答：
所有调用都会执行基类 Graph 的 draw () 方法，无法调用派生类的具体绘制逻辑。

（2）若 Canvas 类 std::vector<Graph*> 改成 std::vector<Graph> ，会出现什么问题？

答：
会发生对象切片，vector 中存储的是 Graph 基类对象，派生类的特有成员会被截断，无法实现多态特性，调用 draw () 时始终执行基类方法。

（3）若 ~Graph() 未声明成虚函数，会带来什么问题？

答：
析构时仅调用基类 Graph 的析构函数，派生类对象的资源无法释放。

 

问题3：扩展性思考

若要新增星形 Star ，需在哪些文件做哪些改动？逐一列出。

答：

（1）Graph.hpp：新增 Star 类声明class Star : public Graph { public: void draw(); }；

（2）Graph.cpp：实现 Star 类的 draw () 方法void Star::draw() { std::cout << "draw a star...\n"; }，在 str_to_GraphType 函数中添加if (t == "star") return GraphType::star;，在 make_graph 函数中添加case GraphType::star: return new Star;。

（3）demo3.cpp：在 test () 中添加canvas.add("star")。

 

问题4：资源管理

观察 make_graph 函数和 Canvas 析构函数：

（1） make_graph 返回的对象在什么地方被释放？

答：
在 Canvas 类的析构函数中被释放。

（2）使用原始指针管理内存有何利弊？

答：
利：实现简单，直接控制对象生命周期；

弊：容易出现内存泄漏、野指针等问题，安全性较低。

 

实验任务四：
源代码：

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

class Toy {
public:
    Toy(const std::string& name, const std::string& type) : name(name), type(type) {}
    virtual ~Toy() = default;
    virtual std::string getSpecialFunction() const = 0;  // 纯虚函数，特异功能
    std::string getName() const { return name; }
    std::string getType() const { return type; }

private:
    std::string name;   // 玩具名称
    std::string type;   // 玩具类型
};

// 唱歌玩具类
class SingingToy : public Toy {
public:
    SingingToy(const std::string& name) : Toy(name, "唱歌玩具") {}
    std::string getSpecialFunction() const override;
};

// 发光玩具类
class LightingToy : public Toy {
public:
    LightingToy(const std::string& name) : Toy(name, "发光玩具") {}
    std::string getSpecialFunction() const override;
};

// 互动玩具类
class InteractiveToy : public Toy {
public:
    InteractiveToy(const std::string& name) : Toy(name, "互动玩具") {}
    std::string getSpecialFunction() const override;
};

// 玩具工厂类
class ToyFactory {
public:
    ~ToyFactory();
    void addToy(Toy* toy);          // 添加玩具
    void showAllToys() const;       // 展示所有玩具信息

private:
    std::vector<Toy*> toys;         // 管理所有玩具
};

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

// 唱歌玩具特异功能实现
std::string SingingToy::getSpecialFunction() const {
    return "播放流行歌曲，支持音量调节";
}

// 发光玩具特异功能实现
std::string LightingToy::getSpecialFunction() const {
    return "七彩灯光闪烁，支持呼吸灯模式";
}

// 互动玩具特异功能实现
std::string InteractiveToy::getSpecialFunction() const {
    return "语音识别，响应触摸互动，讲故事";
}

// 玩具工厂析构函数：释放玩具资源
ToyFactory::~ToyFactory() {
    for (Toy* toy : toys) {
        delete toy;
    }
}

// 添加玩具
void ToyFactory::addToy(Toy* toy) {
    if (toy) {
        toys.push_back(toy);
    }
}

// 展示所有玩具信息
void ToyFactory::showAllToys() const {
    std::cout << "=============== 玩具工厂产品信息 ===============\n";
    for (size_t i = 0; i < toys.size(); ++i) {
        std::cout << "玩具" << (i + 1) << ":\n";
        std::cout << "  名称：" << toys[i]->getName() << "\n";
        std::cout << "  类型：" << toys[i]->getType() << "\n";
        std::cout << "  特异功能：" << toys[i]->getSpecialFunction() << "\n\n";
    }
}

#include "Toy.hpp"

int main() {
    ToyFactory factory;
    // 添加不同类型玩具
    factory.addToy(new SingingToy("音乐小熊"));
    factory.addToy(new LightingToy("彩虹小兔"));
    factory.addToy(new InteractiveToy("智能机器人"));
    
    // 展示所有玩具信息
    factory.showAllToys();
    return 0;
}

实验结果：

实验结论：

应用的问题场景描述

答：

一个简易的玩具工厂管理系统，用于统一管理多种类型的电子毛绒玩具（如唱歌玩具、发光玩具、互动玩具），并批量展示每个玩具的名称、类型及特异功能。

陈述各类之间的关系（继承、组合等）及设计理由

答：

继承：

class SingingToy : public Toy

class LightingToy : public Toy

class InteractiveToy : public Toy

 

组合：

std::vector<Toy*> toys

 

设计理由：基类Toy作为抽象父类，通过继承关系派生出SingingToy、LightingToy、InteractiveToy等具体玩具类，利用虚函数实现多态特性 —— 既统一了所有玩具的访问接口，又复用了Toy类中 “名称、类型” 等通用字段，符合 “is-a”（具体玩具是一种玩具）的关系逻辑。ToyFactory类通过组合std::vector<Toy*>来管理所有玩具对象，体现 “has-a”（玩具工厂包含一组玩具）的关系，既实现了玩具集合的批量存储与生命周期管理，又能通过基类指针统一调用不同玩具的功能，后续新增玩具类型时，只需添加新的Toy派生类即可，无需修改工厂的管理逻辑，保证了代码的可扩展性与功能清晰度。