Test4
任务一
源代码
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; // 脏标记，记录是否成绩信息有变更
};
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>());
}
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; // 更新脏标记
}
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();
}
int main()
{
test();
}
结果展示
实验结论
问题1：组合关系识别
GradeCalc类声明中，逐行写出所有体现"组合"关系的成员声明，并用一句话说明每个被组合对象的功能。
答：
声明: std::string course_name 功能：保存课程名称。
声明: std::vector<int> grades 功能：保存所有学生的成绩。
声明: std::array<int, 5> counts 功能：记录各分数段的人数计数。
声明: std::array<double, 5> rates; 功能：记录各分数段的占比。
问题2：接口暴露理解
如在test模块中这样使用，是否合法？如不合法，解释原因。
GradeCalc c("OOP");
c.input(5);
c.push_back(97); // 合法吗？
答：不合法。原因是push_back是grades（私有成员）的接口，外部不能通过c.push_back访问。
问题3：架构设计分析
当前设计方案中，compute在info模块中调用：
（1）连续打印3次统计信息，compute会被调用几次？标记is_dirty起到什么作用？
答：1次。原因：构造时is_dirty为true，第一次info()会调用compute()并在compute()中把is_dirty = false；后两次info()因is_dirty==false不再调用compute()。
is_dirty的作用：脏标记，只在数据变更后触发重新统计，避免重复。
（2）如新增update_grade(index, new_grade),这种设计需要更改compute调用位置吗？简洁说明理由。
答：不需要。只需在所有会修改grades的函数内设置is_dirty = true;
问题4：功能扩展设计
要增加"中位数"统计，不新增数据成员怎么做？在哪个函数里加？写出伪代码。
答：在info()中添加代码。
void printMedian(const std::vector<int>& grades) {
if (grades.empty()) {
std::cout << "没有成绩输入！";
return;
}
// 复制
std::vector<int> tmp = grades;
// 升序排序
std::sort(tmp.begin(), tmp.end());
//计数
int n = static_cast<int>(tmp.size());
double median;
if (n % 2 == 1) {
// 元素个数为奇数
median = tmp[n / 2];
} else {
// 元素个数为偶数
median = (tmp[n / 2 - 1] + tmp[n / 2]) / 2.0;
}
std::cout << median;
}
问题5：数据状态管理
GradeCalc和compute中都包含代码：counts.fill(0); rates.fill(0);。
compute中能否去掉这两行？如去掉，在哪种使用场景下会引发统计错误？
答：不能。原因：compute()在每次统计前必须清零计数与比例，否则会受上一次的结果影响。
场景：第一次调用compute()后,grades被修改并再次调用compute()。
问题6：内存管理理解
input模块中代码grades.reserve(n);如果去掉：
（1）对程序功能有影响吗？（去掉重新编译、运行，观察功能是否受影响）
答：在功能方面没有影响。
（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; // 脏标记，记录是否成绩信息有变更
};
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();
}
结果展示
实验结论
问题1：继承关系识别
写出GradeCalc类声明体现"继承"关系的完整代码行。
答：
class GradeCalc : private std::vector<int>
问题2：接口暴露理解
当前继承方式下，基类vector的接口会自动成为GradeCalc的接口吗？
如在test模块中这样用，能否编译通过？用一句话解释原因。
GradeCalc c("OOP");
c.input(5);
c.push_back(97); // 合法吗？
答：当前继承方式下，基类vector<int>的接口不会成为GradeCalc的公有接口,此处是私有继承。
不能。原因push_back是std::vector<int>的公有成员，但因私有继承在GradeCalc中变为私有，外部不能调用。
问题3：数据访问差异
对比继承方式与组合方式内部实现数据访问的一行典型代码。说明两种方式下的封装差异带来的数据访问接口差异。
// 组合方式
for(auto grade: grades) // 通过什么接口访问数据
// 略
// 继承方式
for(int grade: *this)
// 略
答：组合把容器作为实现细节封装在成员变量中，可以更加清晰明确地使用；继承会把容器的语义和接口混入类的行为中，语义不清晰。
问题4：组合 vs. 继承方案选择
你认为组合方案和继承方案，哪个更适合成绩计算这个问题场景？简洁陈述你的结论和理由。
答：组合方案。从问题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); // 创建图形，返回堆对象指针
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();
}
结果展示
实验结论
问题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()，不会根据指针所指实际派生类型调用派生类的draw()。
（2）若Canvas类std::vector<Graph*>改成std::vector，会出现什么问题？
答：将派生类对象按值放入std::vector<Graph>时，派生部分会被切掉，导致丢失派生类特性和行为,不能实现多态存储。
（3）若~Graph()未声明成虚函数，会带来什么问题？
答：通过Graph*指针删除派生类对象时,不会调用派生类的析构函数,无法释放对象。
问题3：扩展性思考
若要新增星形Star，需在哪些文件做哪些改动？逐一列出。
答：
Graph.hpp：
在enum class GraphType中添加枚举项star。
增加class Star: public Graph { public: void draw(); };的声明。
Graph.cpp：
添加void Star::draw() { std::cout << "draw a star...\n"; }的实现。
在str_to_GraphType中识别 "star"。
在make_graph的switch分支中添加case GraphType::star: return new Star;。
demo3.cpp：
调用canvas.add("star");。
问题4：资源管理
观察make_graph函数和Canvas析构函数：
（1）make_graph返回的对象在什么地方被释放？
答：在Canvas::~Canvas()里通过delete循环释放。
（2）使用原始指针管理内存有何利弊？
答：
优点：实现简单、开销小
缺点：存在内存泄漏等安全问题。
任务四
源代码
Toy.hpp
点我展开代码
#pragma once
#include <string>
#include <iostream>
class Toy
{
public:
Toy(const std::string &cname, const std::string &ctype, int cid = 0, int cprice = 0)
: id{cid}, Name{cname}, Type{ctype}, Price{cprice} {}
virtual ~Toy() = default;
// 显示玩具基本信息
virtual void showInfo() const
{
std::cout << "ID:" << id << " Name: " << Name << "\tType: " << Type << "\tPrice:" << Price << std::endl;
}
// 玩具的特异功能
virtual void ability() = 0;
const std::string &name() const { return Name; }
const std::string &type() const { return Type; }
protected:
int id;
std::string Name;
std::string Type;
int Price;
};
// 具体玩具类别：玩偶，游戏机，积木
class Doll : public Toy
{
public:
Doll(const std::string &name, int id = 0, int price = 0) : Toy(name, "Doll", id, price) {}
void showInfo() const override { Toy::showInfo(); }
void ability() override { std::cout << Name << " 抱抱睡觉！\n"; }
~Doll() override = default;
};
class GameConsole : public Toy
{
public:
GameConsole(const std::string &name, int id = 0, int price = 0) : Toy(name, "GameConsole", id, price) {}
void showInfo() const override { Toy::showInfo(); }
void ability() override { std::cout << Name << " 游戏狂欢！\n"; }
~GameConsole() override = default;
};
class BuildingBlocks : public Toy
{
public:
BuildingBlocks(const std::string &name, int id = 0, int price = 0) : Toy(name, "BuildingBlocks", id, price) {}
void showInfo() const override { Toy::showInfo(); }
void ability() override { std::cout << Name << " 积木搭建！\n"; }
~BuildingBlocks() override = default;
};
ToyFactory.hpp
点我展开代码
#pragma once
#include "Toy.hpp"
#include <vector>
#include <string>
class ToyFactory
{
public:
ToyFactory() = default;
~ToyFactory();
// 添加一个玩具到工厂
void add(Toy *toy);
// 显示工厂中所有玩具的信息
void showAll() const;
// 逐一尝试每个玩具的特异功能
void tryAll();
private:
std::vector<Toy *> toys;
};
ToyFactory.cpp
点我展开代码
#include "ToyFactory.hpp"
#include <algorithm>
#include <iostream>
void ToyFactory::add(Toy *toy)
{
if (toy)
toys.push_back(toy);
}
void ToyFactory::showAll() const
{
std::cout << "玩具数量：" << toys.size() << " 玩具列表:\n";
for (const auto &t : toys)
{
if (t)
t->showInfo();
}
}
void ToyFactory::tryAll()
{
std::cout << "尝试所有玩具的特异功能:\n";
for (const auto &t : toys)
{
if (t)
{
std::cout << "- ";
t->ability();
}
}
}
ToyFactory::~ToyFactory()
{
for (Toy *t : toys)
delete t;
toys.clear();
}
demo4.cpp
点我展开代码
#include <iostream>
#include "ToyFactory.hpp"
int main()
{
ToyFactory factory;
// 添加几个玩具到工厂
factory.add(new Doll("Cute Bear", 1, 99));
factory.add(new GameConsole("PSP", 2, 1299));
factory.add(new BuildingBlocks("Lego Set", 3, 499));
// 显示工厂中所有玩具信息
factory.showAll();
std::cout << std::endl;
// 逐一尝试每个玩具的特异功能
factory.tryAll();
std::cout << std::endl;
return 0;
}
结果展示
实验结论
应用的问题场景描述
答：一个简单的玩具工厂，用来管理若干不同种类的玩具并展示它们的信息与特性。
陈述各类之间的关系（继承、组合等）及设计理由
答：
继承：
class Doll : public Toy
class GameConsole : public Toy
class BuildingBlocks : public Toy
组合：
std::vector<Toy *> toys
设计理由：
Toy采用抽象基类Toy＋派生类（Doll、GameConsole、BuildingBlocks）的继承与虚函数实现多态以统一接口并复用字段（id/Name/Type/Price），ToyFactory则通过成员std::vector<Toy *> toys以组合方式拥有并管理玩具集合，功能清晰、易扩展（新增玩具只需新增派生类）。
浙公网安备 33010602011771号