实验四
task1
源代码
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;：固定存储 5 个分数段的人数统计结果。
std::array<double, 5> rates;：固定存储 5 个分数段的人数占比。
问题2：接口暴露理解
如在 test 模块中这样使用，是否合法？如不合法，解释原因。
GradeCalc c("OOP");
c.inupt(5);
c.push_back(97); // 合法吗?答：
不合法。GradeCalc通过组合封装了vector<int>，未暴露push_back接口，外部无法直接调用
问题3：架构设计分析
当前设计方案中， compute 在 info 模块中调用：
（1）连续打印3次统计信息， compute 会被调用几次？标记 is_dirty 起到什么作用？
（2）如新增 update_grade(index, new_grade) ,这种设计需要更改 compute 调用位置吗？简洁说明理由。
答：
（1)1次。id_dirty起判断数据是否有变更的作用，若无变更则不需要调用compute。
（2）不用，因为需不需要调用compute本来就是在函数开头判断的，只需要在函数中更新id_dirty=true。
问题4：功能扩展设计
要增加"中位数"统计，不新增数据成员怎么做？在哪个函数里加？写出伪代码。
答：
在info函数里加
查看代码
double median_val = 0.0;
if (!grades.empty()) {
std::vector<int> temp = grades; // 拷贝原数据，避免修改
std::sort(temp.begin(), temp.end());
int n = temp.size();
if (n % 2 == 1) {
median_val = temp[n / 2]; // 奇数个元素：取中间索引值
} else {
// 偶数个元素：取中间两个值的平均值
median_val = (temp[n/2 - 1] + temp[n/2]) / 2.0;
}
}
std::cout << "中位数:\t" << std::fixed << std::setprecision(2) << median_val << std::endl;问题5：数据状态管理
GradeCalc 和 compute 中都包含代码： counts.fill(0); rates.fill(0); 。
compute 中能否去掉这两行？如去掉，在哪种使用场景下会引发统计错误？
答：
不能。若更新数据则上一次数据仍会保留，导致两次数据一起计算。
问题6：内存管理理解
input 模块中代码 grades.reserve(n); 如果去掉：
（1）对程序功能有影响吗？（去掉重新编译、运行，观察功能是否受影响）
（2）对性能有影响吗？如有影响，用一句话陈述具体影响。
答：
（1）对程序功能无影响，去掉后仍能正常录入、处理成绩。
（2）性能有影响：当录入大量成绩时，vector 会频繁触发内存重分配和数据拷贝，降低程序运行效率。
task2
源代码
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<int> 的接口会自动成为 GradeCalc 的接口吗？
如在 test 模块中这样用，能否编译通过？用一句话解释原因。
GradeCalc c("OOP");
c.input(5);
c.push_back(97); // 合法吗？答：
不会。不能编译通过。原因：GradeCalc 采用私有继承，基类 vector<int>的公有接口（如 push_back）被隐藏，外部无法直接访问。
问题3：数据访问差异
对比继承方式与组合方式内部实现数据访问的一行典型代码。说明两种方式下的封装差异带来的数据访问接口差
异。
// 组合方式
for(auto grade: grades) // 通过什么接口访问数据
// 略
// 继承方式
for(int grade: *this) // 通过什么接口访问数据
// 略答：
组合方式：for (auto grade : grades)，通过成员对象的直接访问接口获取数据；继承方式：for (int grade : *this)，通过派生类自身的迭代器接口访问数据。
封装差异：组合方式完全隐藏成员对象的接口，仅暴露自定义接口，封装性更强；私有继承隐藏基类接口，但派生类可直接使用基类的成员函数，接口控制更灵活但封装性稍弱。
问题4：组合 vs. 继承方案选择
你认为组合方案和继承方案，哪个更适合成绩计算这个问题场景？简洁陈述你的结论和理由。
答：
组合。组合封装性更强，可避免基类接口泄露，且后续可灵活替换成绩存储容器（如改用 array），扩展性更好。
task3
源代码
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中体现"组合"关系的成员声明代码行，并用一句话说明被组合对象的功能。
（2）写出Graph.hpp中体现"继承"关系的类声明代码行。
答：
（1）std::vector<Graph*> graphs;功能：存储多个图形对象的指针，实现 “画布包含多个图形” 的组合关系，支持动态添加和统一管理不同类型的图形
（2）class Circle : public Graphclass Triangle : public Graphclass Rectangle : public Graph
问题2：多态机制观察
（1） Graph 中的 draw 若未声明成虚函数， Canvas::paint() 中 g->draw() 运行结果会有何不同？
（2）若 Canvas 类 std::vector<Graph*> 改成 std::vector<Graph> ，会出现什么问题？
（3）若 ~Graph() 未声明成虚函数，会带来什么问题？
答：
（1）若draw未声明为虚函数：g->draw()会调用基类Graph的draw方法（空实现或默认输出），而非派生类的重写方法，无法实现多态，所有图形都会显示相同的绘制结果（或无输出）。
（2）Graph是抽象基类（含纯虚函数），无法实例化对象；即使Graph是普通类，存储的也只会是基类部分的拷贝，派生类的特有成员会被截断，无法调用派生类的draw方法，多态失效。
（3）析构Canvas中的Graph*对象时，只会调用基类Graph的析构函数，派生类对象的堆内存无法释放，导致内存泄漏。
问题3：扩展性思考
若要新增星形 Star ，需在哪些文件做哪些改动？逐一列出。
答：
（1）Graph.hpp：新增Star类声明（继承Graph，重写draw），更新GraphType枚举添加star；
（2）Graph.cpp：实现Star::draw()方法，更新str_to_GraphType函数支持 “star” 字符串转换，更新make_graph函数添加case GraphType::star: return new Star();；
（3）demo3.cpp：测试时可调用canvas.add("star")添加星形）。
问题4：资源管理
观察 make_graph 函数和 Canvas 析构函数：
（1） make_graph 返回的对象在什么地方被释放？
（2）使用原始指针管理内存有何利弊？
答：
（1）在Canvas析构函数被调用时
（2）优点：实现简单，直接控制对象的创建和释放，灵活性高；
缺点：容易出现内存泄漏（如忘记delete）、野指针（对象释放后指针未置空）、重复释放等问题，需手动管理内存生命周期，代码健壮性依赖开发者经验。
task4
源代码
toy.hpp
查看代码
#pragma once
#include <string>
#include <vector>
// 抽象基类：玩具（定义所有玩具的公共接口和属性）
class Toy {
public:
// 构造函数：初始化玩具名称、品牌（默认电量100，价格0）
Toy(const std::string& name, const std::string& brand)
: name(name), brand(brand), price(0.0), battery_level(100) {
}
// 虚析构函数：确保派生类对象正确析构
virtual ~Toy() = default;
// 公共接口：设置玩具价格（防止负数）
void set_price(double p) {
price = (p > 0) ? p : 0.0;
}
// 纯虚函数：特异功能（子类必须实现，体现多态）
virtual void special_function() const = 0;
// 纯虚函数：展示玩具信息（子类必须实现）
virtual void show_info() const = 0;
protected:
std::string name; // 玩具名称
std::string brand; // 品牌
double price; // 价格（元）
int battery_level; // 电量（0-100，默认满电）
};
// 派生类1：音乐玩具（支持播放歌曲）
class MusicToy : public Toy {
public:
// 构造函数：初始化名称、品牌、内置歌曲列表
MusicToy(const std::string& name, const std::string& brand, const std::vector<std::string>& songs)
: Toy(name, brand), songs(songs) {
}
// 重写：特异功能（播放歌曲）
void special_function() const override;
// 重写：展示音乐玩具专属信息
void show_info() const override;
private:
std::vector<std::string> songs; // 内置歌曲列表
};
// 派生类2：发光玩具（支持发光闪烁）
class GlowToy : public Toy {
public:
// 构造函数：初始化名称、品牌、发光颜色
GlowToy(const std::string& name, const std::string& brand, const std::string& glow_color)
: Toy(name, brand), glow_color(glow_color) {
}
// 重写：特异功能（发光闪烁）
void special_function() const override;
// 重写：展示发光玩具专属信息
void show_info() const override;
private:
std::string glow_color; // 发光颜色（如：粉蓝渐变、七彩）
};
// 派生类3：互动玩具（支持语音对话）
class InteractiveToy : public Toy {
public:
// 构造函数：初始化名称、品牌、互动对话列表
InteractiveToy(const std::string& name, const std::string& brand, const std::vector<std::string>& dialogs)
: Toy(name, brand), dialogs(dialogs) {
}
// 重写：特异功能（语音对话）
void special_function() const override;
// 重写：展示互动玩具专属信息
void show_info() const override;
private:
std::vector<std::string> dialogs; // 互动对话列表
};
// 玩具工厂类（组合多个玩具，提供统一管理接口）
class ToyFactory {
public:
~ToyFactory(); // 析构函数：释放所有玩具的堆内存
void add_toy(Toy* toy); // 添加玩具（传入堆分配的玩具对象）
void show_all_toys() const; // 统一展示所有玩具信息
void trigger_all_functions() const; // 统一触发所有玩具的特异功能
private:
std::vector<Toy*> toys; // 组合管理多个玩具对象（指针容器）
};toy.cpp
查看代码
#include <iomanip>
#include <iostream>
#include "toy.hpp"
// -------------------------- MusicToy 类实现 --------------------------
// 特异功能：播放内置歌曲
void MusicToy::special_function() const {
std::cout << "[音乐玩具] " << name << " 正在播放歌曲：\n";
for (size_t i = 0; i < songs.size(); ++i) {
std::cout << " " << i + 1 << ". " << songs[i] << "\n";
}
std::cout << "电量剩余：" << battery_level << "%\n";
}
// 展示音乐玩具详细信息
void MusicToy::show_info() const {
std::cout << "========================================\n";
std::cout << "玩具名称：" << name << "\n";
std::cout << "品牌：" << brand << "\n";
std::cout << "类型：音乐玩具\n";
std::cout << "价格：" << std::fixed << std::setprecision(2) << price << "元\n";
std::cout << "内置歌曲数量：" << songs.size() << "\n";
std::cout << "========================================\n";
}
// -------------------------- GlowToy 类实现 --------------------------
// 特异功能：发光闪烁
void GlowToy::special_function() const {
std::cout << "[发光玩具] " << name << " 发出 " << glow_color << " 色光芒\n";
std::cout << "闪烁频率：3次/秒 | 电量剩余：" << battery_level << "%\n";
}
// 展示发光玩具详细信息
void GlowToy::show_info() const {
std::cout << "========================================\n";
std::cout << "玩具名称：" << name << "\n";
std::cout << "品牌：" << brand << "\n";
std::cout << "类型：发光玩具\n";
std::cout << "价格：" << std::fixed << std::setprecision(2) << price << "元\n";
std::cout << "发光颜色：" << glow_color << "\n";
std::cout << "========================================\n";
}
// -------------------------- InteractiveToy 类实现 --------------------------
// 特异功能：语音互动
void InteractiveToy::special_function() const {
std::cout << "[互动玩具] " << name << " 正在互动对话：\n";
for (const auto& dialog : dialogs) {
std::cout << " 玩具：" << dialog << "\n";
}
std::cout << "电量剩余：" << battery_level << "%\n";
}
// 展示互动玩具详细信息
void InteractiveToy::show_info() const {
std::cout << "========================================\n";
std::cout << "玩具名称：" << name << "\n";
std::cout << "品牌：" << brand << "\n";
std::cout << "类型：互动玩具\n";
std::cout << "价格：" << std::fixed << std::setprecision(2) << price << "元\n";
std::cout << "互动对话数量：" << dialogs.size() << "\n";
std::cout << "========================================\n";
}
// -------------------------- ToyFactory 类实现 --------------------------
// 析构函数：释放所有玩具对象的堆内存（避免内存泄漏）
ToyFactory::~ToyFactory() {
for (Toy* toy : toys) {
delete toy; // 调用对应派生类的析构函数
}
toys.clear(); // 清空容器（可选，析构后容器本身会销毁）
}
// 添加玩具：仅接收非空指针
void ToyFactory::add_toy(Toy* toy) {
if (toy != nullptr) {
toys.push_back(toy);
}
}
// 统一展示所有玩具信息（多态调用 show_info）
void ToyFactory::show_all_toys() const {
std::cout << "\n【玩具工厂 - 所有玩具信息】\n";
if (toys.empty()) {
std::cout << "工厂暂无玩具！\n";
return;
}
for (Toy* toy : toys) {
toy->show_info(); // 多态：调用对应派生类的 show_info
}
}
// 统一触发所有玩具的特异功能（多态调用 special_function）
void ToyFactory::trigger_all_functions() const {
std::cout << "\n【触发所有玩具特异功能】\n";
if (toys.empty()) {
std::cout << "工厂暂无玩具，无法触发功能！\n";
return;
}
for (Toy* toy : toys) {
toy->special_function(); // 多态：调用对应派生类的 special_function
std::cout << "----------------------------------------\n";
}
}demo4.cpp
查看代码
#include <iostream>
#include <vector>
#include "Toy.hpp"
// 测试函数：创建工厂、添加玩具、测试功能
void test_toy_factory() {
// 1. 创建玩具工厂
ToyFactory factory;
// 2. 创建音乐玩具（堆分配，后续由工厂统一释放）
std::vector<std::string> songs = { "小星星", "两只老虎", "生日歌", "虫儿飞" };
Toy* music_bear = new MusicToy("音乐小熊", "贝乐多", songs);
music_bear->set_price(199.99); // 设置价格
factory.add_toy(music_bear); // 加入工厂
// 3. 创建发光玩具
Toy* glow_rabbit = new GlowToy("发光小兔子", "费雪", "粉蓝渐变");
glow_rabbit->set_price(159.99);
factory.add_toy(glow_rabbit);
// 4. 创建互动玩具
std::vector<std::string> dialogs = {
"你好呀！我是小恐龙～",
"陪我玩一会儿吧，我会讲故事哦！",
"今天天气真好，一起去探险吧！",
"再见啦，下次再一起玩！"
};
Toy* talk_dino = new InteractiveToy("对话小恐龙", "乐高", dialogs);
talk_dino->set_price(299.99);
factory.add_toy(talk_dino);
// 5. 测试：展示所有玩具信息
factory.show_all_toys();
// 6. 测试：触发所有玩具的特异功能
factory.trigger_all_functions();
}
// 主函数
int main() {
std::cout << "===== 电子毛绒玩具管理系统 =====" << std::endl;
test_toy_factory();
return 0;
}运行结果
应用的问题场景描述
设计一套电子毛绒玩具管理系统，支持多种类型的毛绒玩具（如音乐玩具、发光玩具、互动玩具），每种玩具具有独特的特异功能（如播放音乐、发光闪烁、语音对话）。通过玩具工厂类管理所有玩具，提供统一接口展示玩具信息并触发所有玩具的特异功能，体现组合、继承、虚函数的综合应用。
各类之间的关系及设计理由
（1）继承关系：抽象基类Toy定义玩具的公共属性和接口，派生类MusicToy（音乐玩具）、GlowToy（发光玩具）、InteractiveToy（互动玩具）继承自Toy，重写特异功能接口（多态）。
（2）组合关系：ToyFactory（玩具工厂）组合std::vector<Toy*>，管理多个玩具对象，提供添加玩具、展示所有玩具信息、触发所有玩具功能的统一接口。
（3）设计理由：不同玩具属于 “is-a”（是一种）玩具，适合用继承；工厂与玩具属于 “has-a”（包含）关系，适合用组合；虚函数实现多态，使工厂可通过统一接口调用不同玩具的特异功能，便于扩展新玩具类型。
浙公网安备 33010602011771号