实验4
实验任务1：
源代码：
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; // 更新脏标记
}
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; // 脏标记，记录是否成绩信息有变更
};
task.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：std::string course_name;：用于存储课程名称，标识当前成绩计算器所属的课程，为成绩统计信息提供课程上下文。
std::vector
std::array<int, 5> counts;：固定大小为 5 的数组，分别对应 [0, 60)、[60, 70)、[70, 80)、[80, 90)、[90, 100] 这 5 个分数段，用于统计每个分数段的学生人数。
std::array<double, 5> rates;：与counts数组对应，存储每个分数段人数占总人数的比例，便于在info函数中以百分比形式展示各分数段分布情况。
bool is_dirty;：作为状态标记，记录成绩数据或统计信息是否发生变更。当成绩录入、更新等操作导致数据变化时，将其设为true，触发compute函数重新计算统计信息；统计信息计算完成后设为false，避免重复无效计算。
问题2：不合法。
因为GradeCalc类通过组合方式内嵌std::vector
问题3：1次，提高程序效率。
不会，因为这只会修改指定成绩。
问题4：double GradeCalc::median() const {
if (grades.empty())
return 0.0;
std::vector
std::sort(temp_grades.begin(), temp_grades.end());
int size = temp_grades.size();
if (size % 2 == 1)
return temp_grades[size / 2];
else
return (temp_grades[size / 2 - 1] + temp_grades[size / 2]) / 2.0;
}
问题5：不能，当成绩多次变更时出错。
问题6：功能没有，性能有。当成绩录入多时会扩容。
实验任务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"
// 测试函数：创建GradeCalc对象，模拟成绩录入、排序、统计
void test() {
// 创建OOP课程的成绩计算器
GradeCalc c1("OOP");
// 录入5个成绩
std::cout << "请录入5个成绩（范围0-100）:\n";
c1.input(5);
// 输出原始成绩
std::cout << "\n原始成绩:\n";
c1.output();
// 排序（默认降序）并输出
std::cout << "降序排序后成绩:\n";
c1.sort();
c1.output();
// 输出完整统计信息
std::cout << "\n*************OOP课程成绩统计信息*************\n";
c1.info();
}
int main() {
test();
return 0;
}
运行截图：
问题1：
class GradeCalc : private std::vector
问题2：不会
不会，私有成员外部不可见。
问题3：for(auto grade: grades)，通过私有成员变量grades（vector
问题4：组合，拓展性维护性高，更适合。
实验任务3：
源代码：
Graph.hpp
#pragma once
#include <string>
#include <vector>
// 图形类型枚举
enum class GraphType { circle, triangle, rectangle };
// 抽象基类Graph
class Graph {
public:
// 虚函数draw，子类需重写实现具体图形绘制
virtual void draw() {}
// 虚析构函数，确保子类对象析构时释放资源
virtual ~Graph() = default;
};
// 圆形类，继承自Graph
class Circle : public Graph {
public:
void draw() override; // 重写draw函数
};
// 三角形类，继承自Graph
class Triangle : public Graph {
public:
void draw() override; // 重写draw函数
};
// 矩形类，继承自Graph
class Rectangle : public Graph {
public:
void draw() override; // 重写draw函数
};
// 画布类，组合多个图形对象
class Canvas {
public:
void add(const std::string& type); // 根据图形类型字符串添加图形
void paint() const; // 统一接口绘制所有图形
~Canvas(); // 析构函数，释放图形对象内存
private:
std::vector<Graph*> graphs; // 组合vector存储图形指针，体现has-a关系
};
// 工具函数声明
GraphType str_to_GraphType(const std::string& s); // 字符串转换为GraphType枚举
Graph* make_graph(const std::string& type); // 根据类型创建图形对象，返回堆指针
Graph.cpp
#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include "Graph.hpp"
// 圆形绘制实现
void Circle::draw() {
std::cout << "draw a circle...\n";
}
// 三角形绘制实现
void Triangle::draw() {
std::cout << "draw a triangle...\n";
}
// 矩形绘制实现
void Rectangle::draw() {
std::cout << "draw a rectangle...\n";
}
// 画布添加图形：调用工具函数创建图形，存入vector
void Canvas::add(const std::string& type) {
Graph* g = make_graph(type);
if (g != nullptr) { // 确保创建成功后再添加
graphs.push_back(g);
}
}
// 画布统一绘制：遍历所有图形，调用draw（多态生效）
void Canvas::paint() const {
for (Graph* g : graphs) {
g->draw(); // 动态绑定，调用对应子类的draw
}
}
// 画布析构：释放所有图形对象的堆内存，避免内存泄漏
Canvas::~Canvas() {
for (Graph* g : graphs) {
delete g;
}
graphs.clear(); // 清空指针容器（可选，析构后容器本身也会销毁）
}
// 工具函数：字符串转GraphType（忽略大小写）
GraphType str_to_GraphType(const std::string& s) {
std::string lower_str = s;
// 将输入字符串转为小写，统一判断标准
std::transform(s.begin(), s.end(), lower_str.begin(),
[](unsigned char c) { return std::tolower(c); });
if (lower_str == "circle") {
return GraphType::circle;
} else if (lower_str == "triangle") {
return GraphType::triangle;
} else if (lower_str == "rectangle") {
return GraphType::rectangle;
} else {
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:
std::cerr << "Unsupported graph type! Returning nullptr.\n";
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 << "Start painting all graphs:\n";
canvas.paint(); // 统一调用绘制接口
}
int main() {
test();
return 0;
}
运行截图：
问题1：
private: std::vector<Graph*> graphs;存储多个图形对象的指针，管理图形集合，支持动态添加和遍历图形
class Circle : public Graph ，class Triangle : public Graph 。
问题2：
无输出。
多态失效。
内存泄漏。
问题3：Graph.hpp：
新增Star类声明，公有继承自Graph，并声明draw()函数，更新GraphType枚举，添加star
Graph.cpp：
实现Star::draw()函数，修改str_to_GraphType函数，添加"star"的判断逻辑，修改make_graph函数，添加GraphType::star的 case 分支
在test()函数中添加canvas.add("star");，验证星形绘制功能。
问题4：
通过delete g释放每个图形对象的堆内存，避免内存泄漏。
灵活性高，但是容易内存泄漏。
实验任务4：
源代码：
Toy.hpp
#ifndef TOY_HPP
#define TOY_HPP
#include <string>
#include <iostream>
#include <vector>
#include <memory>
class Toy {
protected:
std::string name;
std::string type;
std::string specialType;
public:
Toy(const std::string& n, const std::string& t, const std::string& st);
virtual ~Toy() {
virtual void showSpecialFunction() const = 0;
void displayInfo() const;
std::string getName() const { return name; }
std::string getType() const { return type; }
std::string getSpecialType() const { return specialType; }
};
class SingingToy : public Toy {
private:
std::string songLyrics;
public:
SingingToy(const std::string& n, const std::string& t, const std::string& lyrics);
void showSpecialFunction() const override;
};
class GlowingToy : public Toy {
private:
std::string lightColor;
std::string lightPart;
public:
GlowingToy(const std::string& n, const std::string& t,
const std::string& color, const std::string& part);
void showSpecialFunction() const override;
};
class TalkingToy : public Toy {
private:
std::string dialogue;
public:
TalkingToy(const std::string& n, const std::string& t, const std::string& dialogue);
void showSpecialFunction() const override;
};
class ToyFactory {
private:
std::vector<std::shared_ptr<Toy>> toys;
public:
ToyFactory();
void addToy(std::shared_ptr<Toy> toy);
void createSampleToys();
void displayAllToys() const;
};
#endif // TOY_HPP
Toy.cpp
#include "Toy.hpp"
#include <iostream>
using namespace std;
// ============ Toy 基类实现 ============
Toy::Toy(const std::string& n, const std::string& t, const std::string& st)
: name(n), type(t), specialType(st) {}
void Toy::displayInfo() const {
cout << "名称：" << name << " | 类型：" << type << endl;
}
// ============ SingingToy 实现 ============
SingingToy::SingingToy(const std::string& n, const std::string& t, const std::string& lyrics)
: Toy(n, t, "唱歌"), songLyrics(lyrics) {}
void SingingToy::showSpecialFunction() const {
cout << "[" << specialType << "] " << name << "：" << songLyrics << endl;
}
// ============ GlowingToy 实现 ============
GlowingToy::GlowingToy(const std::string& n, const std::string& t,
const std::string& color, const std::string& part)
: Toy(n, t, "发光"), lightColor(color), lightPart(part) {}
void GlowingToy::showSpecialFunction() const {
cout << "[" << specialType << "] " << name << "：（"
<< lightPart << "发出" << lightColor << "彩光）" << endl;
}
// ============ TalkingToy 实现 ============
TalkingToy::TalkingToy(const std::string& n, const std::string& t, const std::string& dialogue)
: Toy(n, t, "对话"), dialogue(dialogue) {}
void TalkingToy::showSpecialFunction() const {
cout << "[" << specialType << "] " << name << "：" << dialogue << endl;
}
// ============ ToyFactory 实现 ============
ToyFactory::ToyFactory() {
// 构造函数
}
void ToyFactory::addToy(std::shared_ptr<Toy> toy) {
toys.push_back(toy);
}
void ToyFactory::createSampleToys() {
// 创建与截图完全一致的示例玩具
auto toy1 = make_shared<SingingToy>("憨憨熊", "毛绒公仔-小熊", "两只老虎，跑得快~");
auto toy2 = make_shared<GlowingToy>("跳跳兔", "毛绒公仔-兔子", "粉色", "耳朵");
auto toy3 = make_shared<TalkingToy>("汪汪狗", "毛绒公仔-小狗", "你好呀！我是你的毛绒伙伴~");
addToy(toy1);
addToy(toy2);
addToy(toy3);
}
void ToyFactory::displayAllToys() const {
cout << "--- 玩具工厂 - 所有玩具信息 ---" << endl;
cout << endl;
for (const auto& toy : toys) {
toy->displayInfo();
toy->showSpecialFunction();
cout << endl;
}
cout << "--------------------------------" << endl;
}
task4.cpp
#include "Toy.hpp"
#include <iostream>
using namespace std;
int main() {
cout << "设计性实验：综合运用组合、继承、虚函数" << endl;
cout << "实现用一个接口尝试所有玩具特异功能" << endl;
cout << "======================================" << endl;
cout << endl;
// 第一部分：演示继承和多态
cout << "第一部分：演示继承和多态" << endl;
cout << "=========================" << endl;
cout << endl;
// 使用基类指针指向不同派生类对象
shared_ptr<Toy> toy1 = make_shared<SingingToy>("音乐大象", "毛绒公仔-大象", "小星星，亮晶晶~");
shared_ptr<Toy> toy2 = make_shared<GlowingToy>("闪光恐龙", "毛绒公仔-恐龙", "绿色", "背部");
shared_ptr<Toy> toy3 = make_shared<TalkingToy>("智能熊猫", "毛绒公仔-熊猫", "我爱吃竹子！");
// 通过基类指针调用虚函数，展示多态
cout << "通过基类Toy指针调用showSpecialFunction()：" << endl;
cout << endl;
cout << "玩具1：" << toy1->getName() << endl;
toy1->displayInfo();
cout << "功能展示：";
toy1->showSpecialFunction();
cout << endl;
cout << "玩具2：" << toy2->getName() << endl;
toy2->displayInfo();
cout << "功能展示：";
toy2->showSpecialFunction();
cout << endl;
cout << "玩具3：" << toy3->getName() << endl;
toy3->displayInfo();
cout << "功能展示：";
toy3->showSpecialFunction();
cout << endl;
cout << "======================================" << endl;
cout << endl;
// 第二部分：演示玩具工厂功能
cout << "第二部分：演示玩具工厂功能" << endl;
cout << "==========================" << endl;
cout << endl;
// 创建玩具工厂并添加玩具
ToyFactory factory;
factory.createSampleToys();
// 显示所有玩具信息（与截图完全一致）
factory.displayAllToys();
cout << endl;
// 第三部分：演示动态创建玩具
cout << "第三部分：动态创建新玩具并测试" << endl;
cout << "==============================" << endl;
cout << endl;
// 动态创建新玩具
ToyFactory dynamicFactory;
// 添加各种类型的玩具
dynamicFactory.addToy(make_shared<SingingToy>("唱歌小鸟", "毛绒公仔-小鸟", "春天在哪里呀~"));
dynamicFactory.addToy(make_shared<GlowingToy>("发光海豚", "毛绒公仔-海豚", "蓝色", "鳍部"));
dynamicFactory.addToy(make_shared<TalkingToy>("对话狮子", "毛绒公仔-狮子", "我是森林之王！"));
dynamicFactory.addToy(make_shared<SingingToy>("摇滚猴子", "毛绒公仔-猴子", "我们是害虫~"));
dynamicFactory.addToy(make_shared<GlowingToy>("梦幻独角兽", "毛绒公仔-独角兽", "彩虹色", "独角"));
// 显示动态创建的玩具
dynamicFactory.displayAllToys();
cout << endl;
cout << "程序运行结束。" << endl;
return 0;
}
运行截图：
浙公网安备 33010602011771号