实验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; // 脏标记，记录是否成绩信息有变更
};
点击查看代码
#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
std::array<int, 5> counts：存储5个分数段的人数。
std::array<double, 5> rates：存储5个分数段的人数占比。
问题2：接口暴露理解
如在 test 模块中这样使用，是否合法？如不合法，解释原因。
回答：不合法。push_back 是 vector
问题3：架构设计分析
当前设计方案中， compute 在 info 模块中调用：
（1）连续打印3次统计信息， compute 会被调用几次？标记 is_dirty 起到什么作用？
回答：compute被调用1次；is_dirty用于标记成绩是否变更，仅在变更后首次调用 info时触发compute，避免重复计算。
（2）如新增 update_grade(index, new_grade) ,这种设计需要更改 compute 调用位置吗？简洁说明理由。
回答：不需要；新增update_grade时设置is_dirty = true，后续调用info会自动触发compute。
问题4：功能扩展设计
要增加"中位数"统计，不新增数据成员怎么做？在哪个函数里加？写出伪代码。
回答：在average()函数后新增median()函数，利用已有grades计算。
点击查看代码
double median() const {
if (grades.empty()) return 0.0;
std::vector<int> temp = grades;
std::sort(temp.begin(), temp.end());
int n = temp.size();
return n % 2 == 1 ? temp[n/2] : (temp[n/2 - 1] + temp[n/2]) / 2.0;
}
问题5：数据状态管理
GradeCalc 和 compute 中都包含代码： counts.fill(0); rates.fill(0); 。
compute 中能否去掉这两行？如去掉，在哪种使用场景下会引发统计错误？
回答：不能去掉。若去掉，多次调用 compute会导致counts和rates累加旧数据，引发统计错误。
问题6：内存管理理解
input 模块中代码 grades.reserve(n); 如果去掉：
（1）对程序功能有影响吗？（去掉重新编译、运行，观察功能是否受影响）
回答：无功能影响，程序仍能正常录入、计算成绩。
（2）对性能有影响吗？如有影响，用一句话陈述具体影响。
回答：大量成绩录入时，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; // 脏标记，记录是否成绩信息有变更
};
点击查看代码
#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 类声明体现"继承"关系的完整代码行。
回答：
点击查看代码
<details>
<summary>点击查看代码</summary>
class GradeCalc: private std::vector
</details>
回答：不会自动成为接口；不能编译通过。采用私有继承，基类vector
问题3：数据访问差异
对比继承方式与组合方式内部实现数据访问的一行典型代码。说明两种方式下的封装差异带来的数据访问接口差异。
回答：组合方式：通过私有成员变量 grades 直接访问。
继承方式：通过 *this 直接访问。
差异：组合是“has-a”，封装性更强，外部无法访问内部容器；继承是“is-a”，私有继承虽隐藏基类接口，但内部可直接复用基类功能。
问题4：组合 vs. 继承方案选择
你认为组合方案和继承方案，哪个更适合成绩计算这个问题场景？简洁陈述你的结论和理由。
回答：组合更适合。理由：成绩计算器与 vector 是“包含”关系，组合封装性更好，可灵活控制接口，且避免继承带来的接口冗余或权限问题。
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); // 创建图形，返回堆对象指针
点击查看代码
#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() 运行结果会有何不同？
回答： 所有 g->draw() 都调用基类 Graph 的空 draw，无法实现多态，无法绘制具体图形。
（2）若 Canvas 类 std::vector<Graph> 改成 std::vector
回答：vector
（3）若 ~Graph() 未声明成虚函数，会带来什么问题？
回答：析构时仅调用基类析构函数，子类对象的内存无法释放，导致内存泄漏。
问题3：扩展性思考
若要新增星形 Star ，需在哪些文件做哪些改动？逐一列出。
回答：Graph.hpp：新增 Star 类声明继承 Graph，更新 GraphType 枚举和 str_to_GraphType、make_graph 声明。
Graph.cpp：实现 Star::draw()，完善 str_to_GraphType识别“star”和 make_graph创建Star对象。
demo3.cpp：在 test 中添加 canvas.add("star")。
问题4：资源管理
观察 make_graph 函数和 Canvas 析构函数
（1） make_graph 返回的对象在什么地方被释放？
回答：在 Canvas 的析构函数中，通过 delete g 释放。
（2）使用原始指针管理内存有何利弊？
回答：利：直接控制内存，灵活高效；弊：易遗漏释放、野指针风险，可读性和维护性差。
4. 实验任务4
你设计的应用的问题场景描述
回答：设计的是一款电子发光玩具，比原来多添加了发光功能。针对发光毛绒玩具，实现玩具的名称价格的基础信息管理、核心功能控制包括亮灯、调亮度、关灯，并通过玩具工厂完成玩具的批量添加、库存展示、功能测试等操作。
陈述各类之间的关系（继承、组合等）及设计理由
回答：
继承：LightToy继承Toy 基类。Toy定义了玩具的名称、价格等公共属性和亮灯、调亮度、关灯的接口，LightToy作为具体的发光玩具，属于“is-a”玩具，因此继承基类并实现这些接口，同时新增亮度、开关状态等专属属性。
组合：ToyFactory里包含 vector<Toy*> 容器，工厂需要管理多个玩具对象，通过容器“包含”玩具，能统一完成添加、展示等操作，方便管理玩具的生命周期。
Toy.hpp源码
点击查看代码
#pragma once
#include <string>
#include <vector>
class Toy {
public:
Toy(std::string n, int p) : name(n), price(p) {}
virtual ~Toy() = default;
virtual std::string getType() const = 0;
virtual void on() = 0; // 亮灯
virtual void setBright(int b) = 0; // 调亮度
virtual void off() = 0; // 关灯
std::string getName() const { return name; }
int getPrice() const { return price; }
private:
std::string name;
int price;
};
class LightToy : public Toy {
public:
LightToy(std::string n, int p) : Toy(n, p), bright(1), isOn(false) {}
std::string getType() const override { return "发光玩具"; }
void on() override;
void setBright(int b) override;
void off() override;
private:
int bright; // 1-3档亮度
bool isOn; // 开关状态
};
class ToyFactory {
public:
~ToyFactory();
void add(Toy* t);
void showAll() const;
private:
std::vector<Toy*> toys;
};
点击查看代码
#include "Toy.hpp"
#include <iostream>
ToyFactory::~ToyFactory() {
for (Toy* t : toys) delete t;
toys.clear();
std::cout << "\n资源释放\n";
}
void ToyFactory::add(Toy* t) {
if (t) {
toys.push_back(t);
std::cout << "添加：" << t->getName() << "\n";
}
}
void ToyFactory::showAll() const {
if (toys.empty()) {
std::cout << "无玩具\n";
return;
}
std::cout << "\n===== 发光玩具清单 =====\n";
for (size_t i = 0; i < toys.size(); i++) {
Toy* t = toys[i];
std::cout << i+1 << ". 名称：" << t->getName() << " | 价格：" << t->getPrice() << "元\n";
}
}
// 发光玩具功能实现
void LightToy::on() {
isOn = true;
std::cout << getName() << " 亮灯（当前亮度" << bright << "档）\n";
}
void LightToy::setBright(int b) {
if (b >= 1 && b <= 3) {
bright = b;
if (isOn) {
std::cout << getName() << " 亮度调为" << b << "档\n";
} else {
std::cout << getName() << " 已设亮度" << b << "档（未亮灯）\n";
}
} else {
std::cout << getName() << " 亮度仅支持1-3档\n";
}
}
void LightToy::off() {
isOn = false;
std::cout << getName() << " 关灯\n";
}
点击查看代码
#include "Toy.hpp"
#include <iostream>
using namespace std;
int main() {
ToyFactory f;
LightToy* t1 = new LightToy("星空兔", 89);
LightToy* t2 = new LightToy("荧光熊", 99);
f.add(t1);
f.add(t2);
f.showAll();
cout << "\n===== 测试发光功能 =====\n";
t1->on();
t1->setBright(3);
t1->off();
t2->setBright(2);
t2->on();
t2->setBright(5); // 无效亮度
return 0;
}
实验总结：
这次实验主要学了继承和组合。组合封装性强，适合部件组合，例如成绩计算器含成绩容器；继承侧重复用，搭配虚函数实现多态，例如图形绘制。
浙公网安备 33010602011771号