实验四
task1
GradeCalc.hpp
#pragma once
#include<vector>
#include<array>
#include<string>
class GradeCalc{
public:
GradeCalc(const std::string &cname);
void input(int 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::vector<int> grades;
std::array<int,5> counts;
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=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];
else if(grade<70)
++counts[1];
else if(grade<80)
++counts[2];
else if(grade<90)
++counts[3];
else
++counts[4];
}
for(int 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();
}
A1:std::string course_name;可存储课程名称；std::vector
A2:不合法。std::vector
A3:(1) 1 次。is_dirty 标记的作用是：仅当成绩数据发生变更时才触发 compute 重新计算统计信息，可以避免重复计算，提升程序效率。
(2) 不需要。理由：新增 update_grade时会修改成绩数据，只需在该方法中设置 is_dirty = true，后续调用 info() 时会自动触发 compute。
A4:无需新增数据成员，在 GradeCalc 类中新增 median() 成员函数
类声明中添加：double median() const;
double GradeCalc::median() const {
if (grades.empty()) return 0.0;
std::vector
std::sort(temp.begin(), temp.end());
int n = temp.size();
return (n % 2 == 1) ? temp[n/2] : (temp[n/2 -1] + temp[n/2])/2.0;
}
A5:不能。若去掉，当成绩数据发生多次变更时，counts 和 rates 会保留上一次的统计结果，导致新统计结果与旧数据叠加，出现统计错误。
A6:(1) 无影响。
(2) 有影响.当录入的成绩数量 n 较大时，去掉 reserve(n) 会导致 vector 频繁触发自动扩容，降低程序运行效率。
task2
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);
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;
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];
else if (grade < 70)
++counts[1];
else if (grade < 80)
++counts[2];
else if (grade < 90)
++counts[3];
else
++counts[4];
}
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();
}
A1:class GradeCalc: private std::vector
A2:不会。GradeCalc 采用私有继承 外部无法通过 GradeCalc 对象访问。
A3:组合方式通过私有成员对象直接访问 数据，依赖类内部暴露的成员变量;继承方式通过 派生类自身直接访问 数据，依赖继承关系带来的基类成员访问权限。
A4:组合方案更适合。成绩计算器与成绩集合组合更符合语义；组合的封装性更好，可完全控制外部访问接口，避免误操作成绩数据.
task3
Graph.hpp
#pragma once
#include<string>
#include<vector>
enum class GraphType{circle,triangle,rectangle};
class Graph{
public:
virtual void draw() {}
virtual ~Graph()=default;
};
class Circle:public Graph{
public:
void draw();
};
class Triangle:public Graph{
public:
void draw();
};
class Rectangle:public Graph{
public:
void draw();
};
class Canvas{
public:
void add(const std::string& type);
void paint() const;
~Canvas();
private:
std::vector<Graph*> graphs;
};
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"
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";
}
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();
}
A1：（1）std::vector<Graph*> graphs; 统一存储多个图形对象的指针，支持图形的添加和批量绘制。
（2）class Circle : public Graph
class Triangle : public Graph
class Rectangle : public Graph
A2：(1) 所有调用都会执行基类 Graph::draw()，无具体图形绘制输出。
(2) 发生对象切片问题。子类对象存入 std::vector
（3）仅调用基类析构函数，子类对象的堆内存未被释放，造成内存泄漏。
A3:Graph.hpp：
枚举 GraphType 新增 star：enum class GraphType { circle, triangle, rectangle, star };
声明 Star 类：class Star : public Graph { public: void draw() override; };
Graph.cpp：
实现 Star::draw()：void Star::draw() { std::cout << "draw a star...\n"; }
修改 str_to_GraphType：新增 if (t == "star") return GraphType::star;
修改 make_graph：新增 case GraphType:⭐ return new Star;
demo3.cpp：测试时添加 canvas.add("star");
A4:(1) make_graph 返回的对象在 Canvas 类的析构函数中被释放。
(2) 利：灵活控制对象生命周期，无需依赖智能指针的语法限制，适合简单场景的手动管理。弊：易出现内存泄漏、野指针、重复释放等问题，代码维护成本高。
task4
Toy.hpp
#pragma once
#include <string>
#include <vector>
#include <ctime>
class Toy {
public:
Toy(const std::string& name, const std::string& type, double price);
virtual ~Toy() = default;
virtual void specialFunction() const = 0;
virtual void showInfo() const;
protected:
std::string name;
std::string type;
double price;
std::string productionDate;
};
class SingingBear : public Toy {
public:
SingingBear(const std::string& name, double price);
void specialFunction() const override;
void showInfo() const override;
};
class GlowingRabbit : public Toy {
public:
GlowingRabbit(const std::string& name, double price);
void specialFunction() const override;
void showInfo() const override;
};
class WalkingDog : public Toy {
public:
WalkingDog(const std::string& name, double price);
void specialFunction() const override;
void showInfo() const override;
};
class ToyFactory {
public:
~ToyFactory();
void addToy(Toy* toy);
void showAllToys() const;
private:
std::vector<Toy*> toys;
};
Toy.cpp
#include <iostream>
#include <<iomanip>
#include <ctime>
#include "Toy.hpp"
std::string getCurrentDate() {
time_t now = time(nullptr);
tm* tm_now = localtime(&now);
char buf[20];
sprintf(buf, "%04d-%02d-%02d", tm_now->tm_year + 1900, tm_now->tm_mon + 1, tm_now->tm_mday);
return std::string(buf);
}
Toy::Toy(const std::string& name, const std::string& type, double price)
: name(name), type(type), price(price), productionDate(getCurrentDate()) {}
void Toy::showInfo() const {
std::cout << "【玩具基础信息】\n";
std::cout << "名称：" << name << "\n";
std::cout << "类型：" << type << "\n";
std::cout << "价格：" << std::fixed << std::setprecision(2) << price << "元\n";
std::cout << "生产日期：" << productionDate << "\n";
}
SingingBear::SingingBear(const std::string& name, double price)
: Toy(name, "毛绒电子玩具", price) {}
void SingingBear::specialFunction() const {
std::cout << "【特异功能】：播放儿歌《小星星》，音量可调节～\n";
}
void SingingBear::showInfo() const {
Toy::showInfo(); // 调用基类方法显示基础信息
specialFunction(); // 显示特异功能
std::cout << "----------------------------------------\n";
}
GlowingRabbit::GlowingRabbit(const std::string& name, double price)
: Toy(name, "毛绒电子玩具", price) {}
void GlowingRabbit::specialFunction() const {
std::cout << "【特异功能】：耳朵发出七彩渐变光，支持常亮/闪烁模式～\n";
}
void GlowingRabbit::showInfo() const {
Toy::showInfo();
specialFunction();
std::cout << "----------------------------------------\n";
}
WalkingDog::WalkingDog(const std::string& name, double price)
: Toy(name, "毛绒电子玩具", price) {}
void WalkingDog::specialFunction() const {
std::cout << "【特异功能】：模拟小狗爬行，前进/转弯，伴随叫声～\n";
}
void WalkingDog::showInfo() const {
Toy::showInfo();
specialFunction();
std::cout << "----------------------------------------\n";
}
ToyFactory::~ToyFactory() {
for (Toy* toy : toys)
delete toy;
}
void ToyFactory::addToy(Toy* toy) {
if (toy)
toys.push_back(toy);
}
void ToyFactory::showAllToys() const {
std::cout << "===== 玩具工厂产品清单（共" << toys.size() << "个玩具）=====\n";
for (const Toy* toy : toys) {
toy->showInfo(); // 多态调用子类showInfo
}
}
demo4.cpp
#include <iostream>
#include "Toy.hpp"
int main() {
ToyFactory factory;
factory.addToy(new SingingBear("快乐小熊", 99.99));
factory.addToy(new GlowingRabbit("彩虹小兔", 89.99));
factory.addToy(new WalkingDog("活力小狗", 109.99));
factory.showAllToys();
return 0;
}
实验总结
组合与继承的语义差异：组合是 “has-a” 关系，适合复用对象功能；继承是 “is-a” 关系，适合复用类的结构和接口。多态的实现条件，基类声明虚函数、子类重写虚函数、通过基类指针引用调用，核心价值是 “统一接口，不同实现”，降低代码耦合。封装的重要性，组合通过隐藏内部成员提升封装性，继承需谨慎选择继承方式，良好的封装可降低维护成本。手动管理堆对象时，需确保析构函数正确释放资源，避免内存泄漏。
浙公网安备 33010602011771号