实验4 组合与继承
实验任务1
代码组织：
GradeCalc.hpp 类GradeCalc声明
GradeCalc.cpp 类GradeCalc实现
demo1.cpp 测试代码 + main.cpp
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; // 更新脏标记
}
demo1.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：体现组合关系的成员声明及其功能：
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; // 保存各分数段人数占比
问题2：不合法，对象c的类型是GradeCalc，该类没有定义名为push_back()的成员函数，因此不合法，且push_back()的相关功能是封装在input()成员函数中的，即使c.push_back(97);语句合法，在语义上也执行了不安全的input()操作，从语义上看也是不合法的。
问题3（1）：因为是连续打印，所以数据没有被修改，因此compute()函数仅会被调用一次，标记is_dirty用于标记数据是否是新的，如果是，就重新计算相关特征值，避免每次输出时都重新计算，加快运行速度。
（2）：不需要更改，数据成员的输出和排序都只操作grade本身，不涉及特征值计算，只有info()功能会需要特征值，因此只在该函数中判定并调用compute()功能即可，不需要更改调用位置。
问题4：在不新增数据成员的情况下输出中位数，因为不能新增数据成员，所以这个数据没有持续性，只能在输出函数中增加处理这个数据的功能，因此应该加在info()功能函数中：
std::cout << "中位数:\t" << std::fixed << std::setprecision(2) <<
[](std::vector<int> g) {
if (g.empty())
return 0.0;
else if (g.size() % 2)
return g[g.size()/2] * 1.0;
else
return (g[g.size()/2 - 1] + g[g.size()/2])/2.0;
}(grades) << std::endl;
直接使用lambda匿名函数算出中位数再控制格式输出就可以了。
问题5：compute()中的count.fill(0);不能去掉，该数组元素的处理方式默认数据初始时为0，如果去掉更新数据时会出问题；rates数组的元素由于全部由赋值存入，可以不初始化为0
问题6：（1）对程序运行没有影响。（2）一次分配足够的内存，避免vector多次重分配。
实验任务2
代码组织：
GradeCalc.hpp 类GradeCalc声明
GradeCalc.cpp 类GradeCalc实现
demo2.cpp 测试代码 + main.cpp
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;
}
demo2.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<int>
问题2： c.push_back(97);语句不合法，派生类数据成员与基类不同，push_back()无法适配，编译不通过。
问题3：组合类使用vector开放的公有接口遍历动态数组元素，继承类使用类内的接口访问数据成员。
问题4：组合类更适合，显然GradeCalc是有一个grades动态数组存储数据而非类本身是一个动态数组，因此组合类更合适。
实验任务3
代码组织：
Graph.hpp Graph 类、Cirle 类、Rectangle 类、Triangle 类、Canvas 类声明
Graph.cpp 类实现
demo3.cpp 测模块 + main
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）：体现组合关系的成员声明：std::vector<Graph*> graphs;
功能：维护一个存储图形类对象指针的动态数组。
（2）：体现继承关系的成员声明：
class Circle : public Graph
class Triangle : public Graph
class Rectangle : public Graph
问题2（1）：因为g是Graph*类型的所以会直接调用Graph类的draw()导致没有输出结果。
（2）Graph类的派生类全部被赋值构造函数隐式转换为基类的类型而丢失自己的特征，触发了对象切片，派生类的“派生”信息丢失了，退化成了抽象类。
（3）派生类没有使用自己的析构函数而使用了基类的析构函数，可能引发难以调试的错误。
问题3：1）在GraphType中添加star，2）给出star类继承的定义和实现。
问题4（1）：在~Canva()中由delete g;语句释放。
（2）：操作简便，与基本数据类型一致，但没有将基类的析构函数定义为虚函数可能导致释放内存时发生错误。
实验任务4
问题场景：
关于市场常见类型电子毛绒玩具特异功能测试。
对象关系：
由基类Toy给出数据成员name和修改与输出的公用接口，以及测试函数和析构函数的虚函数接口。3个不同type的子类继承Toy类并具体化测试函数excpt()的实现。使用Container类对象存储具体的toy对象并集中调用测试模块。最后通过main函数调用测试模块添加新对象并测试。
代码组织：
ToyCotainer.hpp Toy类、BiolStim类、IntlInter类、ExtndReal类、Container类、工具函数声明
ToyContainer.cpp 类实现，工具函数实现
task4.cpp 测试模块 main
ToyCotainer.hpp
#pragma once
#include <string>
#include <vector>
enum class ToyType {biolStim, intlInter, extndReal};
class Toy {
private:
std::string name;
public:
void new_name(const std::string& _name) {name = _name;}
std::string& get_name() {return name;}
virtual void excpt() {};
virtual ~Toy() = default;
};
class BiolStim: public Toy {
public:
void excpt();
};
class IntlInter: public Toy {
public:
void excpt();
};
class ExtndReal: public Toy {
public:
void excpt();
};
class Container {
public:
void add(const std::string& type, const std::string& name = " ");
void testfunc() const;
~Container();
private:
std::vector<Toy*> toys;
};
ToyType StrToToyType(const std::string& s);
Toy* MakeToy(const std::string& type, const std::string& name);
ToyContainer.cpp
#include <iostream>
#include <string>
#include <algorithm>
#include "ToyContainer.hpp"
void BiolStim::excpt() {std::cout << "drive the " << get_name() << " function...\n";}
void IntlInter::excpt() {std::cout << "drive the " << get_name() << " function...\n";}
void ExtndReal::excpt() {std::cout << "drive the " << get_name() << " function...\n";}
void Container::add(const std::string& type, const std::string& name) {
Toy* t = MakeToy(type, name);
if (t)
toys.push_back(t);
}
void Container::testfunc() const {
for (auto t : toys)
t->excpt();
}
Container::~Container() {
for (auto t : toys)
delete t;
}
ToyType StrToToyType(const std::string& s) {
std::string temp = s;
std::transform(s.begin(), s.end(), temp.begin(), [](unsigned char c) { return std::tolower(c);});
if ("circle" == temp)
return ToyType::biolStim;
if ("triangle" == temp)
return ToyType::intlInter;
if ("rectangle" == temp)
return ToyType::extndReal;
return ToyType::biolStim;
}
Toy* MakeToy(const std::string& type, const std::string& name) {
Toy* t;
switch (StrToToyType(type)) {
case ToyType::biolStim: t = new BiolStim; break;
case ToyType::intlInter: t = new IntlInter; break;
case ToyType::extndReal: t = new ExtndReal; break;
default: return nullptr;
}
t->new_name(name);
return t;
}
task4.cpp
#include <string>
#include "ToyContainer.hpp"
void test() {
Container containers;
containers.add("biolStim", "Breath Simulation");
containers.add("biolStim", "HeartBeat Simulation");
containers.add("intlInter", "Emotional Recognition");
containers.add("intlInter", "Presonal Memory");
containers.add("extndReal", "AR Interaction");
containers.add("extndReal", "IoT Control");
containers.testfunc();
}
int main()
{
test();
return 0;
}
运行测试结果如下：
实验总结：
类的继承与多态进一步拓展了类的强大功能，但与此同时也存在很多危险的操作，例如将派生类对象赋值给基类对象导致的泄漏，在需要代码同一性和数据存储时可以考虑使用基类对象指针指向派生类对象，对象调用成员函数本质上是使用了函数指针指向类的虚函数表，对象指针又进一步增加了灵活性，允许使用基类指针指向派生类对象并正常通过编译，但在动态申请内存时，要注意申请和释放内存会隐式调用构造函数和析构函数，一定要保证两个函数是正常工作且适合于动态分配内存的对象的，这也是基类析构函数要显式声明成虚函数的原因，防止派生类使用基类析构函数导致意外。
浙公网安备 33010602011771号