实验4
#任务1
##1.源代码
//GradeCal.hpp #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; // 更新脏标记 }
///GradeCal.cpp #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; // 脏标记，记录是否成绩信息有变更 };
##2.运行测试截图
##3.回答问题
问题1：组合关系识别
GradeCalc 类声明中，逐行写出所有体现"组合"关系的成员声明，并用一句话说明每个被组合对象的功能。
答：1.GradeCalc(const std::string &cname);
内嵌对象std::string,功能：实现对字符串的处理
2.std::vector<int> grades;
内嵌对象std::vector<int>,功能：实现动态数组功能（与静态区别：大小可变）
3.std::array<int, 5> counts;
内嵌对象std::array<int,5>,功能：实现静态数组功能
问题2：接口暴露理解 如在 test 模块中这样使用，是否合法？如不合法，解释原因。
GradeCalc c("OOP");
c.inupt(5);
c.push_back(97); // 合法吗？
答：不合法。
原因：1.c是一个GradeCalc类的对象，push_back只能对容器类对象使用（如vector，array这些），但c不是容器类对象
2.c的容器类属性都是private型，也无法直接用push_back函数直接添加值，只能用提供的接口input函数
问题3 ：架构设计分析
当前设计方案中， compute 在 info 模块中调用：
（1）连续打印3次统计信息， compute 会被调用几次？标记 is_dirty 起到什么作用？
答：1次，最后一次更改成绩后，脏标记is_dirty会被置为true，之后每次打印统计信息，会先检验脏标记
第一次is_dirty为true，证明成绩有改变，需要重新计算调用compute函数，调用过compute函数后is_dirty的值被改为
false。之后无论继续多少次打印统计信息，只要中间不穿插改变成绩的操作，检验到is_dirty为false均不会调用compute函数
因此，脏标记的作用是避免无意义的重复调用compute
（2）如新增 update_grade(index, new_grade) ,这种设计需要更改 compute 调用位置吗？简洁说明理由。
答：不需要，compute调用触发条件是is_dirty为true，只要保证update_grade在更改成绩后把is_dirty值变为true，
后续调用info()就会自动触发compute，无需在意位置
问题4：功能扩展设计
要增加"中位数"统计，不新增数据成员怎么做？在哪个函数里加？写出伪代码。
答：可以在info()函数中加，但是这么做会使info函数过于臃肿
感觉最好还是另写一个和min(),max(),avergae()并列的新函数median（）来计算中位数
核心代码如下，在info（）函数也做微小修改，修改后运行截图如下
class GradeCalc { public: // ... 其他已有接口 ... double median() const; // 新增中位数接口 // ... 私有成员不变 ... }; // 2. 在GradeCalc.cpp中实现函数 double GradeCalc::median() const { // 处理成绩为空的情况 if (grades.empty()) { return 0.0; } // 临时拷贝成绩数据并排序以避免修改原成绩顺序 std::vector<int> temp_grades = grades; std::sort(temp_grades.begin(), temp_grades.end()); // 计算中位数：偶数个成绩取中间两位平均值，奇数个取中间位 int size = temp_grades.size(); if (size % 2 == 1) { return static_cast<double>(temp_grades[size / 2]); } else { return (temp_grades[size / 2 - 1] + temp_grades[size / 2]) / 2.0; }
}
问题5：数据状态管理
GradeCalc 和 compute 中都包含代码： counts.fill(0); rates.fill(0); 。
compute 中能否去掉这两行？如去掉，在哪种使用场景下会引发统计错误？
答：不可以。
counts和rates是累加性质的数据，如果调用compute函数之后不清零，那么下次调用compute函数时会在原有成绩分布的数量基础上再 次累加各个分数段的人数，导致各分数段人数和占比完全错误
问题6：内存管理理解
input 模块中代码 grades.reserve(n); 如果去掉：
（1）对程序功能有影响吗？（去掉重新编译、运行，观察功能是否受影响）
答:不影响。
（2）对性能有影响吗？如有影响，用一句话陈述具体影响。
答：有影响，其功能是提前为数组分配足够的内存空间，去掉后可能会因频繁扩容而影响执行效率。
##任务2
###1.源代码
//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(); }
###2.运行测试截图
###3.回答问题
问题1：继承关系识别 写出 GradeCalc 类声明体现"继承"关系的完整代码行。
答：class GradeCalc: private std::vector<int>
问题2：接口暴露理解
当前继承方式下，基类 vector<int> 的接口会自动成为 GradeCalc 的接口吗？
如在 test 模块中这样用，能否编译通过？用一句话解释原因。
GradeCalc c("OOP");
c.input(5);
c.push_back(97); // 合法吗？
答：1.不会，因为gradecalc类私有继承vector<int>类，继承过来的接口成为Gradecalc的私有成员，不是接口
2.不合法，因为继承过来的vector<int>是私有成员，因此他的函数push_back也被封装成私有的，外部代码无法直接访问
问题3：数据访问差异
对比继承方式与组合方式内部实现数据访问的一行典型代码。说明两种方式下的封装差异带来的数据访问接口差
异。
// 组合方式
for(auto grade: grades) // 通过什么接口访问数据
// 略
// 继承方式
for(int grade: *this) // 通过什么接口访问数据
// 略
答：组合方式通过内嵌对象访问接口，而继承方式在对象内部直接通过自身就可以访问，然后通过派生类的对象供外界调用从而访问数据
问题4：组合 vs. 继承方案选择
你认为组合方案和继承方案，哪个更适合成绩计算这个问题场景？简洁陈述你的结论和理由。
答：组合方案更适合，因为GradeCalc与学生成绩数组的关系是has-a 而非is-a，成绩统计类“包括”学生成绩数组，而非“是”学生成绩数组组合方案更加符合逻辑。
##任务3
###1.源代码
//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(); }
###2.运行测试截图
###3.回答问题
问题1：对象关系识别 （1）写出Graph.hpp中体现"组合"关系的成员声明代码行，并用一句话说明被组合对象的功能。
（2）写出Graph.hpp中体现"继承"关系的类声明代码行。
答：（1）
private:
std::vector<Graph*> graphs; 对象vector<>作为私有成员内嵌在类Graph中。其作用：动态存储对象指针
（2）
class Circle : public Graph
class Triangle : public Graph
class Rectangle : public Graph
问题2：多态机制观察 （1） Graph 中的 draw 若未声明成虚函数， Canvas::paint() 中 g->draw() 运行结果会有何不同？
（2）若 Canvas 类 std::vector<graph*> 改成 std::vector <graph>，会出现什么问题？
（3）若 ~Graph() 未声明成虚函数，会带来什么问题？
答：（1） 编译运行不会报错，但是功能无法正常实现。
未声明虚函数，导致基类指针指向派生类后只能调用基类中的draw函数而非派生类的draw函数
基类的draw函数没有进行任何输出操作，最终运行不会打印出draw a circle/triangle/rectangle.没有任何输出
（2） Canvas类容器只能储存基类graph对象，就算硬塞入派生类对象，也只会保存派生类对象中基类对象的属性和函数
无法访问派生类特有的成员，失去多态的特性
（3） Canvas析构函数如下
Canvas::~Canvas() {
for (Graph* g : graphs)
delete g;
}
该析构函数通过基类指针指向派生类对象，并用delete g调用派生类对象的析构函数
如果~Graph()非虚函数，那么基类指针只能调用基类的析构函数，而派生类特有的
一些成员占用的内存无法通过派生类析构函数释放，导致内存泄漏
问题3：扩展性思考
若要新增星形 Star ，需在哪些文件做哪些改动？逐一列出。
答：只需要在Graph.hpp中写一个公有继承Graph的类Star，并写出其特有的函数draw，并在Graph.cpp中写出相关函数实现
class Star : public Graph {
public:
void draw();
};
问题4：资源管理
观察 make_graph 函数和 Canvas 析构函数：
（1） make_graph 返回的对象在什么地方被释放？
（2）使用原始指针管理内存有何利弊？
答：（1）调用Canvas析构函数后被释放
（2）利：直接对内存进行操作，操作效率高。
弊：操作要求较高，容易出错导致内存泄漏
##任务4
###1.介绍
关键类Toy是musicToy，fuzzyToy，actionToy的基类，包含了玩具的基本特征如名称，价格，大小，类型等，
Toy类中的虚函数display能够打印该玩具的基础类型，在派生类的重写display中先调用基类display（），再打印该玩具的特殊属性，实现了代码的复用
ToyFactory类用基类指针数组储存不同类型的函数，并用add函数进行添加
整个项目主要体现了继承的思想
###2.源代码
//Toy.hpp #pragma once #include<array> #include<string> #include<vector> class Toy{ private: std::string name; std::string type; double price; double size; public: Toy() ; Toy(std::string n, std::string t, double p, double s) : name(n), type(t), price(p), size(s) {} std::string getName() const { return name; } std::string getType() const { return type; } double getPrice() const { return price; } double getSize() const { return size; } virtual void display(); //显示玩具的特异功能 virtual ~Toy()=default; }; //换装玩偶 class fuzzyToy :public Toy{ private: std::string clothes; public: fuzzyToy(); void display(); void dress(); //特异功能：换衣服 }; //音乐玩具 class musicToy:public Toy{ private: double volume; public: musicToy(); void display(); void setVolume(double newVolume);//改变音量 void play_music(); //特异功能：放音乐 }; //智能玩具（能动） class actionToy:public Toy{ private: double step; public: actionToy(); void setStep(double newStep); void display(); void move();//特异功能：自行移动 }; class ToyFactory{ public: void add(const std::string& type); void show(); ~ToyFactory(); private: std::vector<Toy *>toys; };
//Toy.cpp #include "Toy.hpp" #include <iostream> #include <iomanip> fuzzyToy::fuzzyToy():Toy("小熊毛绒玩具", "fuzzyToy", 40, 25),clothes("默认服装"){ } void fuzzyToy::dress(){ std::string newClothes = "公主裙"; clothes = newClothes; std::cout<<"特异功能：换装成功！当前服饰：公主裙"; } void fuzzyToy::display(){ Toy::display(); std::cout<<"特有属性：当前服饰 ="<< clothes <<std::endl; dress(); } musicToy::musicToy():Toy("音乐小车", "musicToy", 60, 15), volume(50){ } void musicToy::setVolume(double newVolume){ volume= newVolume; } void musicToy::play_music(){ std::cout<<"播放歌曲：《小星星》,当前音量： "<<volume <<std::endl; } void musicToy::display(){ Toy::display(); std::cout<<"特有属性：播放音乐"<<std::endl; play_music(); } actionToy::actionToy():Toy("机器人", "actionToy", 90, 50), step(3){ } void actionToy::setStep(double newStep){ step=newStep; } void actionToy::move(){ std::cout<<"向前移动 "<<step<<"步"<<std::endl; } void actionToy::display(){ Toy::display(); std::cout<<"特有属性：向前移动"<<std::endl; move(); } void ToyFactory::add(const std::string& type) { Toy* newToy = nullptr; if (type == "fuzzy" || type == "换装") { newToy = new fuzzyToy(); } else if (type == "music" || type == "音乐") { newToy = new musicToy(); } else if (type == "action" || type == "可动") { newToy = new actionToy(); } else { // 非法类型 std::cout<<"不支持的玩具类型：" <<type <<" | 支持类型：fuzzy(换装)、music(音乐)、action(可动)"; } if (newToy != nullptr) { toys.push_back(newToy); std::cout << "成功添加玩具" <<std::endl; } } void ToyFactory::show() { std::cout << "\n==================================== 玩具工厂库存清单 ====================================" << std::endl; if (toys.empty()) { std::cout << "工厂暂无玩具，请先通过 add() 方法添加！" << std::endl; std::cout << "======================================================================================" << std::endl; return; } int idx = 1; for (Toy* toy : toys) { std::cout << "\n第" << idx << "个玩具" << std::endl; toy->display(); } std::cout << "----------------------------------------" << std::endl; idx++; } void Toy::display(){ std::cout << std::fixed << std::setprecision(1); std::cout << "名称：" << getName() << " | 类型：" << getType() << " | 价格：" << getPrice() << "元 | 尺寸：" << getSize() << "cm" << std::endl; } ToyFactory::~ToyFactory(){ for (Toy* toy : toys) { delete toy; } }
//demo.cpp #include <string> #include "Toy.hpp" #include <stdlib.h> void test() { ToyFactory factory; factory.add("fuzzy"); // 换装玩具 factory.add("音乐"); // 音乐玩具（中文类型） factory.add("action"); // 可动玩具 factory.add("car"); //非法输入 factory.show(); } int main(){ test(); system("pause"); return 0; }
###3.运行测试截图
浙公网安备 33010602011771号