实验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)
double median() const; // 新增：返回中位数
void info(); // 输出课程成绩信息
private:
void compute(); // 成绩统计
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>());
is_dirty = true; // 排序后成绩变更，更新脏标记
}
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;
}
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; // 偶数个，返回中间两个平均值
}
}
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" << std::fixed << std::setprecision(2) << median() << 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 = 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 (int 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();
std::cout << "*************再次打印统计信息*************\n";
c1.info(); // 验证is_dirty作用
}
int main() {
test();
return 0;
}
运行测试截图
问题1：组合关系识别
GradeCalc 类声明中，逐行写出所有体现"组合"关系的成员声明，并用一句话说明每个被组合对象的功能。
std::vector<int> grades;：存储课程的所有成绩数据，为后续统计、排序提供数据基础。
std::array<int, 5> counts;：存储 5 个分数段的人数，用于统计信息输出。
std::array<double, 5> rates;：存储 5 个分数段的人数占比，辅助统计信息展示。
问题2： 接口暴露理解
如在 test 模块中这样使用，是否合法？如不合法，解释原因。
GradeCalc c("OOP");
c.inupt(5);
c.push_back(97); // 合法吗？
不合法，原因有两点：
- 存在语法错误，
inupt是input的拼写错误； push_back是std::vector<int>的成员函数，而grades是GradeCalc的私有成员，GradeCalc未暴露该接口，外部无法直接调用。
问题3： 架构设计分析
当前设计方案中， compute 在 info 模块中调用：
（1）连续打印3次统计信息， compute 会被调用几次？标记 is_dirty 起到什么作用？
（2）如新增 update_grade(index, new_grade) ,这种设计需要更改 compute 调用位置吗？简洁说明理由。
（1）compute 会被调用 1 次；is_dirty 的作用是标记成绩数据是否发生变更（如录入、排序、修改），仅当数据变更时才重新执行统计计算，避免重复计算提升效率。
（2）不需要修改 compute 调用位置；理由：update_grade 会修改成绩数据，只需在该函数中设置 is_dirty = true，调用 info 时会自动触发 compute 重新统计。
问题4：功能扩展设计
要增加"中位数"统计，不新增数据成员怎么做？在哪个函数里加？写出伪代码。
在 GradeCalc 类中添加 median 成员函数，利用已有 grades 数据计算：
// 类声明中添加（GradeCalc.hpp）
double median() const;
// 类实现中添加（GradeCalc.cpp）
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();
return size % 2 == 1 ? temp[size/2] : (temp[size/2-1] + temp[size/2])/2.0;
}
问题5：数据状态管理
GradeCalc 和 compute 中都包含代码： counts.fill(0); rates.fill(0); 。
compute 中能否去掉这两行？如去掉，在哪种使用场景下会引发统计错误？
不能去掉这两行；若去掉，当成绩数据变更后多次调用 compute 时，counts 和 rates 会保留上一次的统计结果，导致新统计数据与历史数据累加，出现统计错误（例如：先录入一批成绩统计后，再录入一批成绩重新统计，分数段人数会重复累加）。
问题6：内存管理理解
input 模块中代码 grades.reserve(n); 如果去掉：
（1）对程序功能有影响吗？（去掉重新编译、运行，观察功能是否受影响）
（2）对性能有影响吗？如有影响，用一句话陈述具体影响。
（1）对程序功能 无影响；reserve(n) 仅预分配 n 个元素的内存空间，不影响数据存储和逻辑执行，去掉后 push_back 仍能正常添加元素。
（2）有性能影响；当 n 较大时，去掉后 push_back 可能多次触发内存重新分配和数据拷贝，导致程序运行效率下降。
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(); // 计算成绩统计信息
std::string course_name; // 课程名
std::array<int, 5> counts; // 保存各分数段人数
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>());
is_dirty = true;
}
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 = 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.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 (int 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();
return 0;
}
运行测试截图
问题1：继承关系识别
写出 GradeCalc 类声明体现"继承"关系的完整代码行。
class GradeCalc: private
std::vector
问题2：接口暴露理解
当前继承方式下，基类 vector 的接口会自动成为 GradeCalc 的接口吗？
基类 vector<int> 的接口 不会自动成为 GradeCalc 的接口；
如在 test 模块中这样用，能否编译通过？用一句话解释原因。
GradeCalc c("OOP");
c.inupt(5);
c.push_back(97); // 合法吗？
不能编译通过；原因：GradeCalc 采用私有继承，基类的 push_back 成员函数在类外部不可访问。
问题3：数据访问差异
对比继承方式与组合方式内部实现数据访问的一行典型代码。说明两种方式下的封装差异带来的数据访问接口差异。
// 组合方式
for(auto grade: grades) // 通过什么接口访问数据
// 略
// 继承方式
for(int grade: *this) // 通过什么接口访问数据
// 略
组合方式：通过 私有成员变量 grades 直接访问数据，接口由 GradeCalc 自主设计暴露，封装性强；
继承方式：通过 *this（自身对象） 直接访问基类数据，派生类可直接使用基类的成员，封装性较弱；
问题4：组合 vs. 继承方案选择
你认为组合方案和继承方案，哪个更适合成绩计算这个问题场景？简洁陈述你的结论和理由。
组合方案更适合；理由：成绩计算器与 “成绩集合” 是 “有 - a” 的关系，组合能隐藏 vector 的无关接口（如 clear、erase），避免外部误操作，且后续扩展（如更换存储容器）时改动更小，维护性更强。
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() override;
};
// Triangle类声明
class Triangle : public Graph {
public:
void draw() override;
};
// Rectangle类声明
class Rectangle : public Graph {
public:
void draw() override;
};
// Canvas类声明
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); // 创建图形,返回堆对象指针
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 <iostream>
#include <string>
#include "Graph.hpp"
void test() {
Canvas canvas;
canvas.add("circle");
canvas.add("triangle");
canvas.add("rectangle");
std::cout << "开始绘制所有图形：\n";
canvas.paint();
}
int main() {
test();
return 0;
}
运行测试截图
问题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 ，会出现什么问题？
会发生 对象切片；派生类对象赋值给基类对象时，派生类独有的信息被截断，无法通过基类对象调用派生类的 draw 函数，多态无法实现。
（3）若 ~Graph() 未声明成虚函数，会带来什么问题？
会导致 内存泄漏；析构时仅调用基类 Graph 的析构函数，派生类对象的堆内存无法释放。
问题3：扩展性思考
若要新增星形 Star ，需在哪些文件做哪些改动？逐一列出。
- Graph.hpp：添加
Star类声明（class Star : public Graph { public: void draw() override; }），更新GraphType枚举（添加star）； - Graph.cpp：实现
Star::draw()函数，修改str_to_GraphType（添加t == "star"分支返回GraphType::star），修改make_graph（添加case GraphType::star: return new Star;）； - task3.cpp：测试时添加
canvas.add("star");。
问题4：资源管理
观察 make_graph 函数和 Canvas 析构函数：
（1） make_graph 返回的对象在什么地方被释放？
（2）使用原始指针管理内存有何利弊？
（1）在 Canvas 类的析构函数中释放，通过循环 delete 容器中所有 Graph* 指针。
（2）利：直接控制内存分配和释放，灵活度高；弊：容易遗漏释放导致内存泄漏，异常场景下（如添加图形后抛出异常）可能出现内存管理混乱。
4.实验任务4
问题场景描述
设计一套电子毛绒玩具管理系统，支持多种毛绒玩具（如音乐熊、发光兔、对话猫），每种玩具具备独特的特异功能（播放音乐、发光、语音对话）。通过玩具工厂类统一管理所有玩具，提供接口批量显示玩具的名称、类型、特异功能等信息，体现组合、继承、虚函数的综合应用。
各类之间的关系（继承、组合等）及设计理由
继承关系：MusicBear、GlowingRabbit、TalkingCat 继承自基类 Toy；理由：所有玩具都有名称、类型等共性属性，特异功能通过虚函数实现多态，便于扩展新玩具类型。
组合关系：ToyFactory 组合 std::vector<Toy*>；理由：工厂需要管理多个玩具对象，通过容器统一存储和操作，符合 “工厂包含多个玩具” 的逻辑关系。
Toy.hpp
#pragma once
#include <string>
#include <vector>
// 玩具基类（修改点：构造函数增加brand参数，添加getBrand()接口）
class Toy {
public:
// 新增：构造函数直接初始化brand（派生类通过初始化列表传递）
Toy(const std::string& name, const std::string& type, const std::string& brand);
virtual ~Toy() = default;
virtual std::string getSpecialFunction() const = 0; // 纯虚函数：特异功能
std::string getName() const;
std::string getType() const;
std::string getBrand() const; // 新增：品牌访问接口（public）
private:
std::string name; // 玩具名称（私有）
std::string type; // 玩具类型（私有）
std::string brand; // 品牌（私有，通过getBrand()访问）
};
// 音乐熊玩具（派生类：构造函数用初始化列表调用基类）
class MusicBear : public Toy {
public:
// 修改：通过初始化列表传递brand给基类，而非直接赋值
MusicBear(const std::string& name, const std::string& brand)
: Toy(name, "电子毛绒玩具", brand) {}
std::string getSpecialFunction() const override;
};
// 发光兔玩具（派生类：同音乐熊）
class GlowingRabbit : public Toy {
public:
GlowingRabbit(const std::string& name, const std::string& brand)
: Toy(name, "电子毛绒玩具", brand) {}
std::string getSpecialFunction() const override;
};
// 对话猫玩具（派生类：同音乐熊）
class TalkingCat : public Toy {
public:
TalkingCat(const std::string& name, const std::string& brand)
: Toy(name, "电子毛绒玩具", brand) {}
std::string getSpecialFunction() const override;
};
// 玩具工厂类（修改：通过getBrand()获取品牌）
class ToyFactory {
public:
~ToyFactory();
void addToy(Toy* toy); // 添加玩具
void showAllToys() const; // 显示所有玩具信息
private:
std::vector<Toy*> toys; // 组合玩具对象指针容器
};
Toy.cpp
#include <iostream>
#include <string>
#include "Toy.hpp"
// Toy基类实现（修改：构造函数初始化brand）
Toy::Toy(const std::string& name, const std::string& type, const std::string& brand)
: name(name), type(type), brand(brand) {} // 初始化列表包含brand
std::string Toy::getName() const {
return name;
}
std::string Toy::getType() const {
return type;
}
// 新增：实现品牌访问接口
std::string Toy::getBrand() const {
return brand;
}
// 音乐熊实现（无需修改，构造函数已通过初始化列表传递brand）
std::string MusicBear::getSpecialFunction() const {
return "播放经典儿歌，支持3种音量调节";
}
// 发光兔实现（同音乐熊）
std::string GlowingRabbit::getSpecialFunction() const {
return "触摸发光，支持红、蓝、绿三种颜色切换";
}
// 对话猫实现（同音乐熊）
std::string TalkingCat::getSpecialFunction() const {
return "语音对话，支持100+常用语句交互";
}
// 玩具工厂析构函数（无修改）
ToyFactory::~ToyFactory() {
for (Toy* toy : toys) {
delete toy; // 释放玩具对象内存
}
}
void ToyFactory::addToy(Toy* toy) {
if (toy) {
toys.push_back(toy);
}
}
// 玩具工厂显示函数（修改：用getBrand()替代直接访问brand）
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]->getBrand() << "\n"; // 调用访问接口
std::cout << " 特异功能：" << toys[i]->getSpecialFunction() << "\n\n";
}
}
demo4.cpp
#include <iostream>
#include "Toy.hpp"
int main() {
ToyFactory factory;
// 添加玩具到工厂
factory.addToy(new MusicBear("快乐熊", "童趣坊"));
factory.addToy(new GlowingRabbit("彩虹兔", "萌趣多"));
factory.addToy(new TalkingCat("智慧猫", "智乐汇"));
// 显示所有玩具信息
factory.showAllToys();
return 0;
}
运行测试截图
浙公网安备 33010602011771号