实验四
试验任务一
源代码
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() {
std::cout << "compute() is called" << std::endl;
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
点击查看代码
#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：
std::string course_name,存储课程名称
std::vector
std::array<int, 5> counts; //用于存放5个预设分数段的人数统计结果。
std::array<double, 5> rates; //用于存放5个预设分数段的人数占比统计结果。
问题2：
不合法。在 GradeCalc 类中，std::vector
问题3：
（1）被调用了一次（加上标记，显示只运行一次）is_dirty()用来作为标记，is_dirty为1时，表示统计的数据已经过时，需要更新
info()被调用时，is_dirty为true时，调用compute()重新计算，然后将 is_dirty 设为 false
（2）不需要。因为成绩变更之后，只需要将is_dirty变成true即可。
问题4：
可以在info()函数里面添加中位数统计功能的代码
伪代码：
//创建一个副本，防止更改原来的数组
temp_grades = copy(grades)
//升序排列
sort(temp_grades)
//求中位数
size = temp_grades.size()
if(size%2==0)
median = (temp_grades[size / 2 - 1] + temp_grades[size / 2]) / 2.0
else
median = temp_grades[size / 2]
//打印结果
std::cout << “中位数是” << median << std::endl;
问题5：
在文档的代码中可以去掉。
但是在多次输入数据时候，不能省略。这两行代码的功能非别为在调用compute()时，将counts和rates数组数据置零，以便于重新开始统计。
删除之后，counts里面储存每个分数段的人数，在第二次输入成绩的时候
（1）counts没有被置零，那么第一次输入5个数据之后，继续输入五个数据，遍历10个数据那么总人数会加10，但是
counts没有置零，会多出五个人。
（2）rates也是，会多出一些百分比。
在task1.cpp中进行二次输入成绩：
实验结果，数据明显有问题，15个人，150%
问题6：
input 模块中代码 grades.reserve(n); 如果去掉：
（1）对于程序功能没有影响。程序的功能（录入成绩、计算、输出）仍然是完全正常的。std::vector 会在需要时自动管理内存，即使不预留空间。
（2）对于性能有影响。具体影响：会导致多次不必要的内存重新分配和数据拷贝，降低 input 函数的执行效率。
试验任务二
源代码
GradeCal.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; // 脏标记，记录是否成绩信息有变更
};
GradeCal.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：
class GradeCalc: private std::vector
问题2：
不会，继承方式是private，基类的公有接口会变成GradeCalc的私有成员。
不能通过。c.push_back(97)中，push_back在GradeCalc类中是私有成员，不能被外部调用
问题3：
（1）组合方式封装性更好。GradeCalc 只能通过 vector 对象的 public 接口来访问其功能，例如 grades.size()，无法触及 vector 的内部实现。
（2）继承方式破坏了一定的封装性。GradeCalc 内部可以直接访问 vector 的 public 和 protected 成员，例如直接调用 size()。
问题4：
我认为组合方案更合适。
GradeCalc 和 std::vector 之间是“有一个”（has-a）的关系，而不是“是一个”（is-a）的关系。也就是说，一个 GradeCalc 对象内部包含一组学生的成绩，但 GradeCalc 本身不是一个 vector。GradeCalc 的核心职责是成绩的统计与分析，而 vector 只是用来存储成绩数据的工具。使用组合可以更好地隐藏内部实现细节，提供清晰稳定的接口，避免把vector的所有接口不必要地加入到GradeCalc 类中。
试验任务三
源代码
Graph.hpp
点击查看代码
#pragma once
#include <string>
#include <vector>
enum class GraphType {circle, triangle, rectangle};
// Graph类定义
class Graph {
public:
void draw() {};
~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 <cstring> // 添加这个头文件以使用strcpy
#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：
问题2：
（1）
源代码输出结果
删除virtual之后输出结果
将Graph类中的draw实现，输出验证信息。我们会发现， Canvas::paint() 中 g->draw() 运行结果变成空，也就是说Canvas::paint() 中 g->draw()调用了基类中的draw()而不是派生类的draw()；
（3）我们可以在Circle类添加构造函数和析构函数
去除virtual ~Graph()，的virtual，那么派生类的析构函数被跳过
会造成内存泄漏的情况。
派生类析构函数被跳过的根本原因，是编译器在编译时根据指针的静态类型 Graph* 进行了静态绑定，直接生成了调用 ~Graph() 的代码，而没有使用动态绑定去探寻指针在运行时的真正身份。
问题3：
1.在Graph.hpp中，GraphType 枚举中添加 star，，在 Rectangle 声明之后，Star 类的声明。
2.在Graph.cpp中，添加 Star::draw() 方法的实现，更新 str_to_GraphType 函数以识别字符串 "star"，更新 make_graph 函数以创建 Star 对象。
3.在demo3.cpp中，增加canvas.add("star")。
问题4：
make_graph 函数返回的堆对象指针被添加到 Canvas 类的 graphs 成员（一个 std::vector<Graph*>）中。这些对象在 Canvas 类的析构函数 ~Canvas() 中通过循环遍历 graphs 并对每个指针调用 delete 来释放。
利：性能开销低: 与智能指针（如 std::unique_ptr 或 std::shared_ptr）相比，原始指针没有额外的内存（用于控制块）和性能开销。
灵活性高: 提供了对内存最直接的控制。
弊：容易导致内存泄漏: 忘记调用 delete 会导致内存无法释放。
试验任务四
源代码
Toy.hpp
点击查看代码
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <memory>
class Toy {
public:
Toy(const std::string& name, const std::string &color,const std::string& type, double price);
virtual ~Toy() = default;//让编译器自己生成一个默认清理内存的版本
// 公共接口
virtual void display_info() const;
// 纯虚函数，定义统一的特异功能接口
virtual void show_special_feature() const = 0;
std::string get_name() const;
std::string get_type() const;
std::string get_color() const;
protected: // 允许派生类访问
std::string name;
std::string type;
std::string color;
double price;
};
// 普通毛绒玩具
class PlushToy : public Toy {
public:
PlushToy(const std::string& name, const std::string &color, double price, const std::string& material);
void display_info() const override;
void show_special_feature() const override;//override重写
private:
std::string material;
};
// 电子毛绒玩具
class ElectronicToy : public Toy {
public:
ElectronicToy(const std::string& name, const std::string& color, double price, bool needs_batteries);
void display_info() const override;
void show_special_feature() const override;
private:
bool needs_batteries;
};
class ToyFactory {
public:
void add_toy(std::unique_ptr<Toy> toy);
void display_all_toys_info() const;
void try_all_special_features() const;
private:
std::vector<std::unique_ptr<Toy>> toys;
};
Toy.cpp
点击查看代码
#include "Toy.hpp"
#include <iostream>
//实现基类
Toy::Toy(const std::string& name, const std::string& color,const std::string& type, double price)
: name(name), color(color),type(type), price(price) {
}
void Toy::display_info() const {
std::cout << "名称: " << name <<", 颜色："<< color<< ", 类型: " << type << ", 价格: " << price << "元";
}
std::string Toy::get_name() const {
return name;
}
std::string Toy::get_color() const {
return color;
}
std::string Toy::get_type() const {
return type;
}
// PlushToy 实现
PlushToy::PlushToy(const std::string& name, const std::string& color, double price, const std::string& material)
: Toy(name, color, "普通毛绒玩具", price), material(material) {
}
void PlushToy::display_info() const {
Toy::display_info();
std::cout << ", 材质: " << material << std::endl;
}
void PlushToy::show_special_feature() const {
std::cout << "特异功能: 我非常柔软，抱起来很舒服！" << std::endl;
}
// ElectronicToy 实现
ElectronicToy::ElectronicToy(const std::string& name,const std::string& color, double price, bool needs_batteries)
: Toy(name,color,"电子毛绒玩具", price), needs_batteries(needs_batteries) {
}
void ElectronicToy::display_info() const {
Toy::display_info();
std::cout << ", 需要电池: " << (needs_batteries ? "是" : "否") << std::endl;
}
void ElectronicToy::show_special_feature() const {
std::cout << "特异功能: 我会唱歌和跳舞，还会跑！" << std::endl;
}
void ToyFactory::add_toy(std::unique_ptr<Toy> toy) {
toys.push_back(std::move(toy));
}
void ToyFactory::display_all_toys_info() const {
std::cout << "------ 工厂所有玩具信息 ------" << std::endl;
for (const auto& toy : toys) {
toy->display_info();
}
std::cout << "-----------------------------" << std::endl;
}
void ToyFactory::try_all_special_features() const {
std::cout << "\n------ 尝试所有玩具的特异功能 ------" << std::endl;
for (const auto& toy : toys) {
std::cout << toy->get_name() << " -> ";
toy->show_special_feature();
}
std::cout << "---------------------------------" << std::endl;
}
demo4.cpp
点击查看代码
#include "Toy.hpp"
int main() {
// 创建玩具工厂
ToyFactory factory;
// 创建并添加不同类型的玩具到工厂
factory.add_toy(std::make_unique<PlushToy>("泰迪熊","橙色", 89.9, "棉花"));
factory.add_toy(std::make_unique<ElectronicToy>("电动机器人","灰色", 159.9, true));
factory.add_toy(std::make_unique<PlushToy>("小兔子","粉色", 59.5, "天鹅绒"));
// 显示工厂中所有玩具的完整信息
factory.display_all_toys_info();
// 通过统一接口尝试所有玩具的特异功能
factory.try_all_special_features();
return 0;
}
运行截图
一、问题场景描述：
我们需要模拟了一个现代化的玩具制造工厂。这家工厂不仅生产传统的毛绒玩具，还生产具备声光电效果的电子玩具。为了高效地管理和展示产品，工厂需要一个软件系统来满足以下需求：
首先要能管理不同种类的玩具，并且能够展现在库玩具的详细信息，在向客户或质检员演示时，需要一个统一的操作来触发每一个玩具的“特异功能”，而不需要为每种玩具单独操作。在未来可能会开发更多的玩具，那么系统必须很好的接纳他们，无需重新修改核心代码。
二、类之间的关系及设计理由：
我主要运用继承和组合两种思想，并且通过虚函数实现了多态。
1.继承关系：Toy和PlushToy 、 ElectronicToy之间是继承关系。
Toy是抽象基类，定义了所有玩具具有的基本属性，例如价格、颜色等等。
PlushToy 与 ElectronicToy 是派生类，我把毛绒玩具分为传统的毛绒玩具和电动的毛绒玩具。因为PlushToy 与 ElectronicToy是玩具，他们继承了基类Toy的基本属性，不需要重复定义，节省了开销，同时本身也有一些属于自己的独特的接口，而且为了实现统一接口，那么我们需要实现多态，实现多态可以使用继承。
2.组合关系：
ToyFactory和Toy之间是组合关系，因为工厂本身不是玩具，其内部需要包含玩具的集合，是"has - a"的关系，所以我使用std::vector<std::unique_ptr
实现组合。
五、实验总结
一些收获
1.通过实验，我进一步理解组合和继承的区别，以及使用场合。
继承适用于“is-a”关系，子类扩展或特化父类的行为；如果两个类型在语义上不是“是一个”的关系，尽量不要使用继承。
组合适用于“has-a”关系，通过把对象作为成员，可以在运行时更灵活地组合行为，更易于解耦和测试。
2.并且理解了纯虚函数的使用场景。纯虚函数用于定义接口（抽象基类），强制派生类实现具体方法，从而实现运行时多态，例如统一接口。
浙公网安备 33010602011771号