OOP-实验4
一、任务1
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; // 脏标记，记录是否成绩信息有变更
};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();
}2、运行结果截图
3、问题1：组合关系识别GradeCalc类声明中，逐行写出所有体现"组合"关系的成员声明，并用一句话说明每个被组合对象的功能。
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; // 保存各分数段人数占比
4、问题2：接口暴露理解如在test模块中这样使用，是否合法？如不合法，解释原因。
不合法。push_back()是std::vector<int> 的成员函数，无法调用属于GradeCalc类的私有成员grade。
5、问题3：架构设计分析当前设计方案中，compute在info模块中调用：
（1）连续打印3次统计信息，compute会被调用几次？标记is_dirty起到什么作用？
compute被调用1次；is_dirty避免了重复计算，成绩变化时is_dirty=true，计算统计。
（2）如新增update_grade(index, new_grade),这种设计需要更改compute调用位置吗？简洁说明理由。
不需要，compute是否被调用取决于is_dirty的值。
6、问题4：功能扩展设计 要增加"中位数"统计，不新增数据成员怎么做？在哪个函数里加？写出伪代码。
在info()中加入：
double median const
{
std::vector<int> sorted_grade=grades;
std::sort( sorted_grade.begin(), sorted_grade.end());
if(size%2==0)
{
return(中间两数平均值)；
}
else
return 中间数；
}
7、问题5：数据状态管理
GradeCalc和compute中都包含代码：counts.fill(0); rates.fill(0);。
compute中能否去掉这两行？如去掉，在哪种使用场景下会引发统计错误？
不能。如果去掉，在已有成绩的基础上更新成绩后，得到的结果会是两次成绩之和。
8、问题6：内存管理理解
input模块中代码grades.reserve(n);如果去掉：
（1）对程序功能有影响吗？（去掉重新编译、运行，观察功能是否受影响）
没有
（2）对性能有影响吗？如有影响，用一句话陈述具体影响
有。reserve(n)可以分配足够的内存，防止出现在录入成绩过多时内存频繁分配的情况。
二、任务2
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";
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;
}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; // 脏标记，记录是否成绩信息有变更
};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();
}2、运行结果截图
3、问题1：继承关系识别写出GradeCalc类声明体现"继承"关系的完整代码行。
class GradeCalc: private std::vector<int>
4、问题2：接口暴露理解 当前继承方式下，基类vector的接口会自动成为GradeCalc的接口吗？ 如在test模块中这样用，能否编译通过？用一句话解释原因。
不会，不能。私有继承使得std::vector<int>的public和protected成员在派生类中都变成了private
5、问题3：对比继承方式与组合方式内部实现数据访问的一行典型代码。说明两种方式下的封装差异带来的数据访问接口差异。
组合方式实现所有数据的封装，无法直接访问grades，只能通过公有接口访问；
继承方式让GradeCalc变成vector，内部可以直接使用基类接口，外部受限
6、问题4：组合 vs. 继承方案选择
你认为组合方案和继承方案，哪个更适合成绩计算这个问题场景？简洁陈述你的结论和理由
我会选择组合。组合方式的灵活性更高，新增规则的时候只需要增加新类或是成员函数，而继承方式中，继承关系确定后新增规则可能导致性能降低。
组合更趋向于“有”，而继承则是“是”，在逻辑关系上理解成绩计算时，计算器不能说是“就是数据本身”
三、任务3
1、源代码
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();
}2、运行结果截图
3、问题1：对象关系识别
（1）写出Graph.hpp中体现"组合"关系的成员声明代码行，并用一句话说明被组合对象的功能。
std::vector<Graph*>graphs;//存储所画图形的指针
（2）写出Graph.hpp中体现"继承"关系的类声明代码行
class Circle : public Graph
class Triangle : public Graph
class Rectangle : public Graph
4、问题2：多态机制观察
（1）Graph中的draw若未声明成虚函数，Canvas::paint()中g->draw()运行结果会有何不同？
Canvas::paint()中g->draw()会调用Graph基类的draw()，输出为空。
（2）若Canvas类std::vector<Graph*>改成std::vector，会出现什么问题？
当派生类对象赋值给基类时，派生类会被切除特有的部分，导致多态的失效。
（3）若~Graph()未声明成虚函数，会带来什么问题？
只能调用基类的析构函数，派生类的析构函数不能被调用，导致内存泄漏。
5、问题3：扩展性思考 若要新增星形Star，需在哪些文件做哪些改动？逐一列出。
A.Graph.hpp：enum class GraphType的star枚举值；继承Graph的Star类
B.Graph.cpp：str_to_GraphType中添加if的判断语句；make_graph中添加case GraphType::star
6、问题4：资源管理 观察make_graph函数和Canvas析构函数：
（1）make_graph返回的对象在什么地方被释放
~Canvas（）
（2）使用原始指针管理内存有何利弊？
利：原始指针方便安全
弊：需要自行控制生命周期，可能导致内存泄漏或重复释放
四、任务4
1、问题场景描述
设计一个玩具工厂，工厂里有各种毛绒玩具，具有不同的特异功能。
2、各类之间的关系及设计理由
A.Toy基类与别的玩具类：继承
玩具类具有Toy基类的基本成员函数，又具有各自特殊的功能，因此采用继承；
B.ToyFactory与玩具类之间为拥有关系，因此采用组合。
3、源代码
Toy.hpp
#ifndef TOY_HPP
#define TOY_HPP
#include <string>
#include <iostream>
//Toy
class Toy
{
protected:
std::string name;
std::string type;
double price;
std::string material;
std::string size;
public:
Toy(const std::string& name, const std::string& type, double price,
const std::string& material, const std::string& size);
virtual ~Toy() = default;
std::string getName() const;
std::string getType() const;
double getPrice() const;
std::string getMaterial() const;
std::string getSize() const;
virtual void displayInfo() const;
virtual void specialFunction() const;
};
class LightUpToy : public Toy
{
public:
LightUpToy(const std::string& name, double price,
const std::string& material, const std::string& size);
void specialFunction() const override;
};
class SoundToy : public Toy
{
public:
SoundToy(const std::string& name, double price,
const std::string& material, const std::string& size);
void specialFunction() const override;
};
class AIToy : public Toy
{
public:
AIToy(const std::string& name, double price,
const std::string& material, const std::string& size);
void specialFunction() const override;
};
class DanceToy : public Toy
{
public:
DanceToy(const std::string& name, double price,
const std::string& material, const std::string& size);
void specialFunction() const override;
};
class MoveToy : public Toy
{
public:
MoveToy(const std::string& name, double price,
const std::string& material, const std::string& size);
void specialFunction() const override;
};
#endif Toy.cpp
#include "Toy.hpp"
// Toy 类的构造函数
Toy::Toy(const std::string& name, const std::string& type, double price,
const std::string& material, const std::string& size)
: name(name), type(type), price(price), material(material), size(size) {}
std::string Toy::getName() const
{
return name;
}
std::string Toy::getType() const
{
return type;
}
double Toy::getPrice() const
{
return price;
}
std::string Toy::getMaterial() const
{
return material;
}
std::string Toy::getSize() const
{
return size;
}
void Toy::displayInfo() const
{
std::cout << "名称: " << name << std::endl;
std::cout << "类型: " << type << std::endl;
std::cout << "价格: " << price << std::endl;
std::cout << "材质: " << material << std::endl;
std::cout << "大小: " << size << std::endl;
}
void Toy::specialFunction() const
{
std::cout << "这款玩具没有特异功能" << std::endl;
}
// LightUpToy 类
LightUpToy::LightUpToy(const std::string& name, double price,
const std::string& material, const std::string& size)
: Toy(name, "可以发光的玩具", price, material, size) {}
void LightUpToy::specialFunction() const
{
std::cout << "拍拍我可以发光" << std::endl;
}
// SoundToy 类
SoundToy::SoundToy(const std::string& name, double price,
const std::string& material, const std::string& size)
: Toy(name, "可以重复说话的玩具", price, material, size) {}
void SoundToy::specialFunction() const
{
std::cout << "这款玩具可以重复你说过的话哦，试着说几句吧" << std::endl;
}
// AIToy 类
AIToy::AIToy(const std::string& name, double price,
const std::string& material, const std::string& size)
: Toy(name, "可以进行AI对话的玩具", price, material, size) {}
void AIToy::specialFunction() const
{
std::cout << "你好我是你的AI小助手，有什么问题吗？" << std::endl;
}
// DanceToy类
DanceToy::DanceToy(const std::string& name, double price,
const std::string& material, const std::string& size)
: Toy(name, "可以跳舞的玩具", price, material, size) {}
void DanceToy::specialFunction() const
{
std::cout << "这款玩具可以跟随音乐舞蹈" << std::endl;
}
// MoveToy 类
MoveToy::MoveToy(const std::string& name, double price,
const std::string& material, const std::string& size)
: Toy(name, "遥控移动", price, material, size) {}
void MoveToy::specialFunction() const
{
std::cout << "控制它去你想去的地方吧" << std::endl;
}ToyFactory.hpp
#ifndef TOYFACTORY_HPP
#define TOYFACTORY_HPP
#include "Toy.hpp"
#include <vector>
class ToyFactory {
private:
std::vector<Toy*> toys;
public:
~ToyFactory();
void addToy(Toy* toy);
void displayAllToys() const;
};
#endifToyFactory.cpp
#include "ToyFactory.hpp"
#include <iostream>
ToyFactory::~ToyFactory() {
for (Toy* toy : toys) {
delete toy;
}
}
void ToyFactory::addToy(Toy* toy) {
toys.push_back(toy);
}
void ToyFactory::displayAllToys() const {
for (const auto& toy : toys) {
toy->displayInfo();
toy->specialFunction();
std::cout << "***************" << std::endl;
}
}task4.cpp
#include "Toy.hpp"
#include "ToyFactory.hpp"
int main()
{
ToyFactory factory;
Toy* toy1 = new LightUpToy("Pokemon" ,50.00,"Plush", "Medium");
Toy* toy2 = new SoundToy("超人", 59.99, "Cotton", "Small");
Toy* toy3 = new MoveToy ("遥控车", 79.99, "Plastic", "Big");
Toy* toy4 = new DanceToy("Barbie", 39.99, "Plush", "Small");
Toy* toy5 = new AIToy("小熊",200.59, "Cotton", "Big");
factory.addToy(toy1);
factory.addToy(toy2);
factory.addToy(toy3);
factory.addToy(toy4);
factory.addToy(toy5);
factory.displayAllToys();
return 0;
}4、运行结果截图
浙公网安备 33010602011771号