实验四

任务一

代码

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

class GradeCalc {
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::vector<int> grades;  
    std::array<int, 5> counts;                  
    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.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;
}

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

效果

 问题

问题1：
std::string course_name; // 记录课程名称
std::vector<int> grades; // 保存所有学生的成绩
std::array<int, 5> counts; // 统计五个分数段的学生人数
std::array<double, 5> rates; // 保存各分数段人数占总人数的比例

问题2：
不合法。原因是`push_back`是`std::vector<int>`的成员函数，而`grades`是`GradeCalc`类的私有成员，外部代码无法直接访问私有成员，且`GradeCalc`类未提供对应的公有接口，因此不能直接调用`push_back`添加成绩。

问题3：
（1）compute会被调用1次。`is_dirty`是脏标记，用于判断成绩数据是否发生变更，只有当数据变更（`is_dirty = true`）时，调用`info`才会重新执行`compute`计算统计信息，避免重复计算以提升性能。
（2）不需要更改`compute`调用位置。理由是`compute`的调用由`is_dirty`的状态决定，新增`update_grade(index, new_grade)`时，只需在该方法中设置`is_dirty = true`，后续调用`info`时会自动检测状态并触发`compute`，无需调整调用位置。

问题4

不新增数据成员的实现方式：新增`median`成员函数，利用已有的`grades`数据，通过复制成绩并排序的方式计算中位数，在`info`函数中调用该函数并输出结果。代码如下：
double GradeCalc::median() const {
if (grades.empty())
return 0.0;
std::vector<int> sorted_grades = grades; // 复制成绩，避免修改原数据
std::sort(sorted_grades.begin(), sorted_grades.end());
size_t n = sorted_grades.size();
if (n % 2 == 1) {
return sorted_grades[n / 2]; // 奇数个数据取中间值
} else {
return (sorted_grades[n / 2 - 1] + sorted_grades[n / 2]) / 2.0; // 偶数个数据取中间两值平均
}
}
```
在`info`函数中添加输出逻辑：`std::cout << "中位数:\t" << std::fixed << std::setprecision(2) << median() << std::endl;`

问题5
不能去掉这两行。如果去掉，当存在成绩更新场景（如先录入成绩计算统计信息，后修改部分成绩再重新计算）时，`counts`和`rates`会在原有统计结果的基础上叠加新数据，导致统计结果错误，无法反映修改后成绩的真实分布。

问题6
（1）对程序功能没有影响，去掉后程序仍能正常编译运行，成绩录入和统计功能不受影响。
（2）对性能有影响。去掉`grades.reserve(n)`后，当录入大量成绩时，`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);
    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;
};

#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];
        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 / 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
体现“继承”关系的完整代码行是：
`class GradeCalc: private std::vector<int>`

问题2
基类`std::vector<int>`的接口不会自动成为`GradeCalc`的接口。
`c.push_back(97);`不能编译通过，原因是：私有继承方式下，基类`std::vector<int>`的所有公有和保护成员在派生类`GradeCalc`中会成为私有成员，外部代码无法直接访问基类的接口。

 问题3
组合方式的典型代码：`for(auto grade: grades)`，通过类内部的成员对象接口访问数据；
继承方式的典型代码：`for(int grade: *this)`，通过派生类自身（复用基类）的接口访问数据。

两者的接口差异：
1. 组合方式中，数据被封装在类内部，外部无法直接访问数据成员，只能通过类提供的公共接口操作数据；
2. 继承方式中，派生类内部可直接使用基类的接口，但外部仍受访问控制限制，无法直接调用基类接口。

问题4
结论：组合方案更适合成绩计算的场景。
理由：
1. 组合的设计更符合实际逻辑：成绩计算器是“使用”成绩数据进行计算，而非“成为”成绩数据本身；
2. 组合可自主控制接口暴露，比如仅开放`input()`录入成绩，避免外部直接修改数据，提升了程序安全性；
3. 组合的灵活性更强，若后续更换成绩的存储方式（不用`vector`），仅需修改类内的成员对象，无需调整类的继承关系。

任务三

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

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

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

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

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

#include <iostream>
#include <string>
#include "Graph.hpp"

void test() {
    Canvas canvas;
    canvas.add("circle");
    canvas.add("triangle");
    canvas.add("rectangle");
    canvas.paint();
}

int main() {
    test();
    return 0;
}

效果

 

问题1：对象关系识别
（1）体现“组合”关系的成员声明代码行：`std::vector<Graph*> graphs;`
被组合对象的功能：用于存储和管理所有图形对象的指针。

（2）体现“继承”关系的类声明代码行：
`class Circle : public Graph`
`class Triangle : public Graph`
`class Rectangle : public Graph`

问题2：多态机制观察
（1）若Graph中的draw未声明为虚函数，Canvas::paint()中`g->draw()`会始终调用Graph基类的draw函数，运行时不会输出子类的绘制信息，仅执行基类的空draw逻辑。

（2）若Canvas类的`std::vector<Graph*>`改为`std::vector<Graph>`，会发生“对象切片”，派生类对象的特有部分被截断，只能存储基类对象，多态功能会完全丢失。

（3）若`~Graph()`未声明为虚函数，通过基类指针删除派生类对象时，仅会调用基类析构函数，派生类的资源无法被正确释放，会造成内存泄漏。

 问题3：扩展性思考
新增星形Star需在以下文件做改动：
1. 在Graph.hpp中：
- 在`enum class GraphType`中添加`star`枚举值；
- 新增`Star`类的声明，使其继承自`Graph`。

2. 在Graph.cpp中：
- 实现`Star`类的`draw`函数；
- 在`str_to_GraphType`函数中添加对“star”字符串的处理；
- 在`make_graph`函数的switch语句中，添加`case GraphType::star`的分支，返回新的`Star`对象。

问题4：资源管理
（1）`make_graph`返回的对象，是在Canvas类的析构函数中被释放的。

（2）使用原始指针管理内存的利弊：
利：
- 使用方式简单直接；
- 可明确管理内存生命周期，对指针的控制更精确。

弊：
- 容易忘记释放内存，导致内存泄漏；
- 可能出现重复释放同一块内存的问题。

任务四

代码

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

class Toy {
protected:
    std::string name_;      // 三丽鸥玩具名称（含角色昵称）
    std::string type_;      // 玩具类型（贴合角色特色）
    double price_;          // 玩具价格（符合三丽鸥周边定价）
    std::string material_;  // 材质（精致感适配三丽鸥产品）
    std::string brand_;     // 品牌固定为"三丽鸥（Sanrio）"
    std::string ageRange_;  // 适用年龄（三丽鸥核心受众）

public:
    Toy(const std::string& name, const std::string& type, double price,
        const std::string& material, const std::string& brand, const std::string& ageRange)
        : name_(name), type_(type), price_(price), material_(material),
          brand_(brand), ageRange_(ageRange) {}

    virtual void specialAbility() const = 0;
    virtual void displayInfo() const;
    virtual ~Toy() = default;

    std::string getName() const { return name_; }
    std::string getType() const { return type_; }
    double getPrice() const { return price_; }
};

// Hello Kitty音乐盒（三丽鸥经典角色：Hello Kitty）
class HelloKittyMusicBox : public Toy {
public:
    HelloKittyMusicBox(const std::string& name, double price, const std::string& material, const std::string& ageRange)
        : Toy(name, "Hello Kitty主题音乐盒", price, material, "三丽鸥（Sanrio）", ageRange) {}

    void specialAbility() const override;
};

// My Melody夜灯（三丽鸥角色：美乐蒂）
class MyMelodyLamp : public Toy {
public:
    MyMelodyLamp(const std::string& name, double price, const std::string& material, const std::string& ageRange)
        : Toy(name, "My Melody感应夜灯", price, material, "三丽鸥（Sanrio）", ageRange) {}

    void specialAbility() const override;
};

// Kuromi互动玩偶（三丽鸥角色：库洛米）
class KuromiDoll : public Toy {
public:
    KuromiDoll(const std::string& name, double price, const std::string& material, const std::string& ageRange)
        : Toy(name, "Kuromi语音互动玩偶", price, material, "三丽鸥（Sanrio）", ageRange) {}

    void specialAbility() const override;
};

// Cinnamoroll毛绒玩具（三丽鸥角色：玉桂狗）
class CinnamorollPlush : public Toy {
public:
    CinnamorollPlush(const std::string& name, double price, const std::string& material, const std::string& ageRange)
        : Toy(name, "Cinnamoroll软萌毛绒玩具", price, material, "三丽鸥（Sanrio）", ageRange) {}

    void specialAbility() const override;
};

class ToyFactory {
private:
    std::vector<Toy*> toys_;

public:
    ToyFactory() = default;
    ~ToyFactory();

    void addToy(Toy* toy);
    void displayAllToys() const;
    void tryAllAbilities() const;
};

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

void Toy::displayInfo() const {
    std::cout << std::fixed << std::setprecision(2);
    std::cout << "【三丽鸥玩具信息】" << std::endl;
    std::cout << "名称: " << name_ << "\t类型: " << type_ << "\t价格: ￥" << price_ << std::endl;
    std::cout << "材质: " << material_ << "\t品牌: " << brand_ << "\t适用年龄: " << ageRange_ << "\n" << std::endl;
}

// Hello Kitty音乐盒功能：播放三丽鸥经典旋律
void HelloKittyMusicBox::specialAbility() const {
    std::cout << "[Hello Kitty-" << name_ << "] 启动功能: 打开顶盖自动播放《Hello Kitty主题曲》， Kitty耳朵随旋律轻晃～\n" << std::endl;
}

// My Melody夜灯功能：感应亮灯+渐变光效
void MyMelodyLamp::specialAbility() const {
    std::cout << "[My Melody-" << name_ << "] 启动功能: 手靠近自动亮灯，支持粉/白/浅紫三色渐变，睡前模式10分钟后自动熄灭～\n" << std::endl;
}

// Kuromi互动玩偶功能：语音对话+录音变声
void KuromiDoll::specialAbility() const {
    std::cout << "[Kuromi-" << name_ << "] 启动功能: 按压头顶说'Kuromi'会回应'嘿！要和我一起捣蛋吗～'，还能录下你的声音变声成可爱语调～\n" << std::endl;
}

// Cinnamoroll毛绒玩具功能：触摸发声+柔软震动
void CinnamorollPlush::specialAbility() const {
    std::cout << "[Cinnamoroll-" << name_ << "] 启动功能: 摸肚子发出'汪汪～'软萌叫声，抱紧时会轻轻震动，模拟撒娇动作～\n" << std::endl;
}

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

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

void ToyFactory::displayAllToys() const {
    std::cout << "==================================== 三丽鸥玩具工厂产品清单 ====================================\n" << std::endl;
    if (toys_.empty()) {
        std::cout << "当前工厂暂无三丽鸥玩具产品！" << std::endl;
        return;
    }
    for (const Toy* toy : toys_) {
        toy->displayInfo();
    }
}

void ToyFactory::tryAllAbilities() const {
    std::cout << "==================================== 三丽鸥玩具特异功能测试 ====================================\n" << std::endl;
    if (toys_.empty()) {
        std::cout << "当前工厂暂无三丽鸥玩具，无法测试功能！" << std::endl;
        return;
    }
    for (const Toy* toy : toys_) {
        toy->specialAbility();
    }
}

#include "Toy.hpp"

void testSanrioToySystem() {
    ToyFactory sanrioFactory;

    // 添加三丽鸥经典角色玩具
    sanrioFactory.addToy(new HelloKittyMusicBox("Kitty酱", 299.99, "ABS树脂+亚克力", "3-12岁"));
    sanrioFactory.addToy(new MyMelodyLamp("Melody甜", 189.80, "硅胶+PC透明壳", "2-10岁"));
    sanrioFactory.addToy(new KuromiDoll("Kuromi酷", 349.00, "短绒布+硅胶", "4-14岁"));
    sanrioFactory.addToy(new CinnamorollPlush("Cinnamoroll软", 259.99, "云朵绒+PP棉", "2-11岁"));
    sanrioFactory.addToy(new HelloKittyMusicBox("Kitty甜", 319.99, "实木+水晶", "5-15岁"));

    // 展示产品+测试功能
    sanrioFactory.displayAllToys();
    sanrioFactory.tryAllAbilities();
}

int main() {
    testSanrioToySystem();
    return 0;
}

效果