实验4
实验4
实验结论:
实验任务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; // 脏标记，记录是否成绩信息有变更
};
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
grades;：存储课程成绩列表 - std::array<int, 5> counts;：存储各分数段人数
- std::array<double, 5> rates;：存储各分数段人数占比
- bool is_dirty;：标记成绩是否变更，控制 compute 是否重算
问题 2: 接口暴露理解
如在 test 模块中这样使用，是否合法？如不合法，解释原因。
GradeCalc c("OOP");
c.input(5);
c.push_back(97);// 合法吗？
不合法。grades是私有成员，push_back是vector成员函数，类外部无法直接调用，且GradeCalc未暴露该接口。
问题 3: 架构设计分析
当前设计方案中，compute 在 info 模块中调用:
(1) 连续打印 3 次统计信息，compute 会被调用几次？标记 is_dirty 起到什么作用？
compute 被调用 1 次；is_dirty 标记成绩是否变更，避免重复计算。
(2) 如新增 update_grade (index, new_grade), 这种设计需要更改 compute 调用位置吗？简洁说明理由。
需修改：update_grade 改成绩后要设 is_dirty=true，否则 info 调用 compute 不触发，统计结果错误（compute 调用位置不变）。
问题 4: 功能扩展设计
要增加 "中位数" 统计，不新增数据成员怎么做？在哪个函数里加？写出伪代码。
在 GradeCalc 新增 median 成员函数（被 info 调用），伪代码：
double median() const {
vector<int> tmp = grades;
sort(tmp.begin(), tmp.end());
int n = tmp.size();
return n ? (n%2 ? tmp[n/2] : (tmp[n/2-1]+tmp[n/2])/2.0) : 0.0;
}
问题 5: 数据状态管理
GradeCalc 和 compute 中都包含代码:counts.fill (0); rates.fill (0);。 compute 中能否去掉这两行？如去掉，在哪种使用场景下会引发统计错误？
不能去掉；多次调用 compute（如成绩变更后），counts/rates 会累加旧数据，统计结果错误。
问题 6: 内存管理理解
input 模块中代码 grades.reserve (n); 如果去掉:
(1) 对程序功能有影响吗？(去掉重新编译、运行，观察功能是否受影响)
无影响
(2) 对性能有影响吗？如有影响，用一句话陈述具体影响。
n 较大时，vector 频繁扩容，增加内存分配和拷贝开销，降低效率。
实验任务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 以 private 方式继承 std::vector
问题3：对比继承方式与组合方式内部实现数据访问的一行典型代码。说明两种方式下的封装差异带来的数据访问接口差异。
// 组合方式
for(auto grade: grades) // 通过什么接口访问数据
// 略 // 继承方式
for(int grade: *this)
// 略 // 通过什么接口访问数据
组合：通过类内 vector 成员（如 grades）的迭代器接口（begin/end）访问；
继承：通过 * this（基类 vector）的迭代器接口访问；
封装差异：组合需通过成员变量公开接口访问，继承直接复用基类接口但外部不可见。
问题4：你认为组合方案和继承方案，哪个更适合成绩计算这个问题场景？简洁陈述你的结论和理由。
组合更适合；成绩计算是 “拥有” 成绩数据（has-a），组合封装性更好，避免继承的接口暴露风险，更易维护。
实验任务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;
}
}
task3.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 中体现“组合”关系的成员声明代码行，并用一句话说明被组合对象的功能。
private: std::vector<Graph *> graphs; //被组合对象 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，会出现什么问5题？
发生对象切片，仅保留 Graph 基类部分，无法调用子类 draw ()，失去多态特性。
（3）若~Graph() 未声明成虚函数，会带来什么问题？
析构 Canvas 时仅调用 Graph 析构，子类析构不执行，导致内存泄漏。
问题3：若要新增星形 Star，需在哪些文件做哪些改动？逐一列出。
- Graph.hpp：新增GraphType::star枚举值；声明class Star : public Graph并声明 draw ()。
- Graph.cpp：实现 Star::draw ()；修改 str_to_GraphType 增加 "star" 转 star 枚举逻辑；修改 make_graph 增加创建 Star 对象的分支。
问题4：观察 make_graph 函数和 Canvas析构函数：
（1）make_graph 返回的对象在什么地方被释放？
在 Canvas 类的析构函数中通过 delete 释放。
（2）使用原始指针管理内存有何利弊？
利：内存释放时机可控、灵活；弊：易引发内存泄漏 / 野指针，需手动管理，代码冗余。
实验任务4:
场景
实现玩具工厂管理系统，管理普通 / 会说话 / 唱歌 / 跳舞的毛绒玩具，展示各玩具属性与特异功能。
类关系
- 继承：
TalkingToy/SingingToy/DancingToy公有继承Toy基类，重写虚函数实现多态； - 组合：
ToyFactory类包含Toy*类型的容器，通过组合管理多个玩具对象。
设计理由
- 继承 + 虚函数：统一玩具接口，子类定制特异功能，基类指针调用实现多态，易扩展新玩具类型；
- 组合：工厂封装玩具存储 / 管理逻辑，解耦玩具与管理功能，析构时统一释放内存，避免泄漏。
源码:
Toy.hpp
#ifndef TOY_HPP
#define TOY_HPP
#include <string>
#include <iostream>
using namespace std;
// 毛绒玩具基类（含虚函数实现多态）
class Toy
{
protected:
string name; // 玩具名称
string type; // 玩具类型（如电动/普通）
string color; // 玩具颜色
double size; // 玩具尺寸（单位：cm）
public:
// 构造函数
Toy(string n, string t, string c, double s);
// 虚析构函数（确保派生类析构被调用）
virtual ~Toy();
// 获取属性的接口
string getName() const;
string getType() const;
string getColor() const;
double getSize() const;
// 虚函数：展示特异功能（子类重写）
virtual void showSpecialAbility() const;
};
// 派生类1：会说话的毛绒玩具
class TalkingToy : public Toy
{
private:
string voice; // 说话内容
public:
TalkingToy(string n, string t, string c, double s, string v);
void showSpecialAbility() const override; // 重写虚函数
};
// 派生类2：会唱歌的毛绒玩具
class SingingToy : public Toy
{
private:
string song; // 歌曲名称
public:
SingingToy(string n, string t, string c, double s, string so);
void showSpecialAbility() const override;
};
// 派生类3：会跳舞的毛绒玩具
class DancingToy : public Toy
{
private:
string dance; // 舞蹈类型
public:
DancingToy(string n, string t, string c, double s, string d);
void showSpecialAbility() const override;
};
#endif // TOY_HPP
Toy.cpp
#include "Toy.hpp"
// 基类Toy构造函数
Toy::Toy(string n, string t, string c, double s)
: name(n), type(t), color(c), size(s) {}
// 基类Toy虚析构函数
Toy::~Toy() {}
// 获取属性的实现
string Toy::getName() const { return name; }
string Toy::getType() const { return type; }
string Toy::getColor() const { return color; }
double Toy::getSize() const { return size; }
// 基类默认特异功能
void Toy::showSpecialAbility() const
{
cout << "【" << name << "】：暂无特异功能~" << endl;
}
// --- 派生类1：TalkingToy ---
TalkingToy::TalkingToy(string n, string t, string c, double s, string v)
: Toy(n, t, c, s), voice(v) {}
void TalkingToy::showSpecialAbility() const
{
cout << "【" << name << "】：我会说话！台词：\"" << voice << "\"" << endl;
}
// --- 派生类2：SingingToy ---
SingingToy::SingingToy(string n, string t, string c, double s, string so)
: Toy(n, t, c, s), song(so) {}
void SingingToy::showSpecialAbility() const
{
cout << "【" << name << "】：我会唱歌！曲目：《" << song << "》" << endl;
}
// --- 派生类3：DancingToy ---
DancingToy::DancingToy(string n, string t, string c, double s, string d)
: Toy(n, t, c, s), dance(d) {}
void DancingToy::showSpecialAbility() const
{
cout << "【" << name << "】：我会跳舞！类型：" << dance << endl;
}
ToyFactory.hpp
#ifndef TOYFACTORY_HPP
#define TOYFACTORY_HPP
#include "Toy.hpp"
#include <vector>
// 玩具工厂类（组合关系：工厂包含多个玩具）
class ToyFactory
{
private:
vector<Toy *> toys; // 存储玩具的容器（基类指针实现多态）
public:
ToyFactory();
~ToyFactory(); // 析构时释放玩具内存
void addToy(Toy *toy); // 添加玩具到工厂
void showAllToys() const; // 显示所有玩具信息+特异功能
};
#endif // TOYFACTORY_HPP
ToyFactory.cpp
#include "ToyFactory.hpp"
// 工厂构造函数
ToyFactory::ToyFactory() {}
// 工厂析构函数：释放所有玩具内存（防止内存泄漏）
ToyFactory::~ToyFactory()
{
for (Toy *t : toys)
{
delete t;
}
toys.clear();
}
// 添加玩具到工厂
void ToyFactory::addToy(Toy *toy)
{
if (toy != nullptr)
{
toys.push_back(toy);
}
}
// 显示所有玩具信息+特异功能（通过基类指针调用虚函数，实现多态）
void ToyFactory::showAllToys() const
{
cout << "============= 玩具工厂清单 =============" << endl;
for (size_t i = 0; i < toys.size(); ++i)
{
cout << "[" << i + 1 << "] 名称：" << toys[i]->getName()
<< " | 类型：" << toys[i]->getType()
<< " | 颜色：" << toys[i]->getColor()
<< " | 尺寸：" << toys[i]->getSize() << "cm" << endl;
toys[i]->showSpecialAbility(); // 调用对应玩具的特异功能
cout << "----------------------------------------" << endl;
}
}
task4.cpp
#include "ToyFactory.hpp"
int main()
{
// 1. 创建玩具工厂
ToyFactory myFactory;
// 2. 添加不同类型的玩具（基类指针指向派生类对象，实现多态）
myFactory.addToy(new TalkingToy("皮卡丘", "电动毛绒", "黄色", 25, "皮卡皮卡~"));
myFactory.addToy(new SingingToy("HelloKitty", "音乐抱枕", "粉色", 40, "小星星"));
myFactory.addToy(new DancingToy("小熊", "摇摆玩偶", "橙色", 30, "左右摇摆舞"));
myFactory.addToy(new Toy("哆啦A梦", "普通挂件", "蓝色", 10)); // 普通玩具
// 3. 显示所有玩具的信息+特异功能
myFactory.showAllToys();
return 0;
}
运行测试截图:
浙公网安备 33010602011771号