实验四
任务一：
1.源代码：
（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; // 脏标记，记录是否成绩信息有变更 };
（2）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; // 更新脏标记 }
（2）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）std::vector<int> grades，具有存储多个成绩的功能；
（2）std::array<int, 5> counts， 具有保存各分数段人数（[0, 60), [60, 70), [70, 80), [80, 90), [90, 100]）的功能；
（3）std::array<double, 5> rates，具有保存各分数段人数占比的功能；这些都是和GradeCalc的组合类。
问题二：
不合法；因为push_back()接口对于GradeCalc类并不是共有接口，只是它的组合类vector的内部接口，并不能直接使用GradeCalc类去直接调用该接口，想要调用也只能先将私有成员组合类vector调用出来，但是这样也违背了私有性，只有共有接口可以暴给外部使用。
问题三：
（1）调用一次；is_dirty()表示记录成绩是否变动，变动则会重新调用一次compute()，否则不调用，这和更新保存文件一个逻辑；
（2）需要；因为正如（1）中所提到的，compute()的功能是更新后重新整理数据，根据updata_grade()该函数的字面定义，是将某一个位置的成绩更改，这样会导致数据变更，如果不在该函数内调用compute去更改数据，只有在调用info时才能更新，这样会导致数据不具有一致性（时效性）。
问题四：
在类内部添加求一个中位数的共有接口；加在public共有部分去声明，后续再去实现；伪代码如下（实现部分）：
double GradeCalc::mid() const{ int size = grades.size(); if(size == 0){ printf("没有记录成绩！"); exit(1); } int mid = grades.size() / 2; if(size % 2 == 1){ return grades.at(mid); }else{ return (grades.at(mid) + grades.at(mid - 1)) / 2.0; } }
问题五：
直接去掉这两行代码后，仍然能够实现代码功能；但是如果去掉后，会在一些使用场景出现问题，例如，当重复使用这个数组时，可能会由于没有删除原先的数据，导致记录新数据时，数据不会覆盖原始数据，导致数据出错。
问题六：
（1）没有影响；
（2）有影响；这个作用是预留空间n,如果不预留，直接调用，会产生额外的内存空间，并且没有存储数据，造成资源浪费。
任务二：
1.源代码：
（1）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; // 脏标记，记录是否成绩信息有变更 };
（2）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; }
（3）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(); GradeCalc c("OOP"); c.input(5); c.push_back(97); // 合法吗？ } int main() { test(); }
2.实验代码运行结果：
3.回答问题：
问题一：
class GradeCalc: private std::vector<int>；
问题二：
不会自动成为，只能在内部去调用vector的接口，但是不能暴露在外；
不能编译通过；因为private是私有继承，只能在继承类内部调用接口；
问题三：
组合方式通过访问成员对象的接口访问数据；继承是通过this指针（自身）的接口访问数据。
问题四：
组合方案；（1）代码可读性较高，逻辑清晰；（2）代码耦合度低，便于维护代码；（3）就问题本身而言，应该符合“has-a”，也就是成绩统计需要这个成绩容器，而不是需要去继承这个容器，不是“is-a”。
任务三：
1.源代码：
（1）Graph.hpp：
#pragma once #include <string> #include <vector> enum class GraphType {circle, triangle, rectangle,star }; // 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(); }; // Star类声明 class Star : 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); // 创建图形，返回堆对象指针
（2）Graph.cpp：
#include <algorithm> #include <cctype> #include <iostream> #include <string> #include "Graph.hpp" // Star类实现 void Star::draw() { std::cout << "draw a star...\n"; } // 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; if (t == "star") return GraphType::star; 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; case GraphType::star: return new Star; default: return nullptr; } }
（3）demo3.cpp：
#include <string> #include "Graph.hpp" void test() { Canvas canvas; canvas.add("star"); canvas.add("circle"); canvas.add("triangle"); canvas.add("rectangle"); canvas.paint(); } int main() { test(); }
2.实验代码运行结果：
3.回答问题：
问题一：
（1）std::vector<Graph*> graphs;
（2）class Circle : public Graph；
class Triangle : public Graph ；
class Rectangle : public Graph；
问题二：
（1）没有打印任何东西；
（2）不能够调用多态对象的方法，而且这样会让多态对象的特殊数据缺少，因为容器中的所有对象都变为了Graph，导致多态对象丢失；
（3）内存泄漏，导致创建的一些多态对象不能被回收。
问题三：
Graph.cpp，Graph.hpp。
问题四：
（1）Canvas的析构函数；
（2）利：占用资源少，能够提高性能；弊：使用不当容易造成内存泄漏，开发者更需要关注这些指针细节，并且容易产生空指针。
任务四：
1.源代码：
（1）ToyFactory.hpp：
#pragma once #include <vector> #include <string> using namespace std; enum class ToyType{ bear,cat,dog,other }; class Toy{ public: Toy(string n = " ",string t = " ",double p = 0,string m = "毛绒"); virtual ~Toy() = default; virtual void function() = 0 ; virtual void print() = 0; protected: string name; string type; double price; string material; }; class BearToy: public Toy{ public: BearToy(string n = "泰迪熊",string t = "bear",double p = 100,string m = "毛绒"); void function();//speak void print(); }; class CatToy: public Toy{ public: CatToy(string n = "小猫",string t = "cat",double p = 120,string m = "毛绒"); void function();//dance void print(); }; class DogToy: public Toy{ public: DogToy(string n = "小狗",string t = "dog",double p = 80,string m = "毛绒"); void function();//emit light void print(); }; class ToyFactory{ public: ToyFactory(string name); ~ToyFactory(); void add(const string& type); void print_all() const; private: string factory_name; vector<Toy*> toys; }; ToyType str_to_ToyType(const string& s); Toy* make_toy(const string& type);
（2）ToyFactory.cpp：
#include "ToyFactory.hpp" #include <iostream> #include <string> BearToy::BearToy(string n, string t,double p, string m) : Toy(n, t, p, m) { } CatToy::CatToy(string n,string t, double p, string m) : Toy(n, t, p, m) { } DogToy::DogToy(string n,string t, double p, string m) : Toy(n, t, p, m) { } void BearToy::function(){ std::cout << "speak\n"; } void CatToy::function(){ std::cout << "dance\n"; } void DogToy::function(){ std::cout << "emit light\n"; } void BearToy::print(){ std::cout << "名称：" << name << " 类型：" << type <<" 价格：" << price << " 材质：" << material << " 功能：" ; this->function(); } void CatToy::print(){ std::cout << "名称：" << name << " 类型：" << type << " 价格：" << price << " 材质：" << material << " 功能：" ; this->function(); } void DogToy::print(){ std::cout << "名称：" << name << " 类型：" << type << " 价格：" << price << " 材质：" << material << " 功能：" ; this->function(); } Toy::Toy(string n,string t,double p,string m): name{n},type{t},price{p},material{m}{ } ToyFactory::ToyFactory(string n): factory_name{n}{ std::cout << factory_name << "工厂已创建！" << std::endl; } ToyFactory::~ToyFactory() { for(Toy* t : toys){ delete t; } } void ToyFactory::add(const string& type){ Toy* t = make_toy(type); if (t) toys.push_back(t); } void ToyFactory::print_all() const{ for (Toy* t : toys) t->print(); } ToyType str_to_ToyType(const string& s){ if (s == "cat") return ToyType::cat; if (s == "dog") return ToyType::dog; if (s == "bear") return ToyType::bear; return ToyType::other; } Toy* make_toy(const string& type){ switch (str_to_ToyType(type)) { case ToyType::cat: return new CatToy; case ToyType::dog: return new DogToy; case ToyType::bear: return new BearToy; default: return nullptr; } }
（3）demo4.cpp:
#include "ToyFactory.hpp" #include<iostream> void test(){ ToyFactory f("玩具"); std::cout << "添加玩具信息：\n"; f.add("cat"); f.add("dog"); f.add("bear"); f.print_all(); } int main(){ test(); }
2.实验代码运行结果：
3.说明：
（1）将Toy作为抽象类，其衍生出的多态类来作为具体玩具实例，这适用于产品多样，但是类别统一的场景，而且ToyFactory工厂也可以产生多个类型的产品，不止Toy；
（2）其中，我设置的CatToy，DogToy，BearToy继承了Toy类，是“is-a”这符合实际问题，并且便于理解逻辑，可以针对每个不同类去针对性改造代码；而ToyFactory的成员对象中，有组合类Vector<Toy>，是“has-a”，这样也可以组装多个不同的Toy，而且可以有让多个vector容器装载多个不同的抽象类（类别），这样便于后续整体功能的增加。
实验总结：
要针对问题场景，通过类之间的关系去合理的使用组合与继承关系。
浙公网安备 33010602011771号