实验4 组合与继承

Task1

1.源代码:

#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;  // 更新脏标记
}

#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;      // 脏标记，记录是否成绩信息有变更
};

#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; // 保存各分数段人数
std::array<double, 5> rates; // 保存各分数段人数占比

问题2：接口暴露理解

如在 test 模块中这样使用，是否合法？如不合法，解释原因。

答:不合法。GradeCalc 类内部只是将 vector 作为一个私有成员进行组合，并没有继承它。而push_back 是 vector 的成员函数，对外部不可见，GradeCalc 没有提供 push_back 接口，所以只能通过公开的 input() 方法录入成绩。

问题3：架构设计分析

当前设计方案中， compute 在 info 模块中调用：

（1）连续打印3次统计信息， compute 会被调用几次？标记 is_dirty 起到什么作用？

答:1次。is_dirty 的作用是避免重复计算，，当成绩数据发生变化时置为 true，表示统计数据已失效，重新计算完成就置为 false。

（2）如新增 update_grade(index, new_grade) ,这种设计需要更改 compute 调用位置吗？简洁说明理由。

答:需要更改。因为如果新增 update_grade(index, new_grade) 接口用于修改某一条成绩，那么必须在这个函数内部将 is_dirty = true;，否则后续调用 info() 不会重新计算统计信息，导致数据显示错误。

问题4：功能扩展设计

要增加"中位数"统计，不新增数据成员怎么做？在哪个函数里加？写出伪代码。

答:可以在 compute() 函数中增加中位数计算。

if(!grades.empty()) {
        std::vector<int> sorted_grades = grades;
        std::sort(sorted_grades.begin(), sorted_grades.end());
        size_t n = sorted_grades.size();
        double median = 0.0;
        if(n % 2 == 1) {
            median = sorted_grades[n/2];
        } else {
            median = (sorted_grades[n/2 - 1] + sorted_grades[n/2]) / 2.0;
        }
    }

问题5：数据状态管理

GradeCalc 和 compute 中都包含代码： counts.fill(0); rates.fill(0); 。compute 中能否去掉这两行？如去掉，在哪种使用场景下会引发统计错误？

答:不能。如果不每次清零 counts 和 rates，再次调用 compute() 时会累加到上次的结果上，造成错误。

问题6：内存管理理解

input 模块中代码 grades.reserve(n); 如果去掉：

（1）对程序功能有影响吗？（去掉重新编译、运行，观察功能是否受影响）

答:没有。

（2）对性能有影响吗？如有影响，用一句话陈述具体影响。

答:有。会导致 vector 在 push_back 过程中多次触发动态扩容，引发频繁的内存重新分配和数据拷贝，降低效率。

 

Task2

1.源代码:

#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;      // 脏标记，记录是否成绩信息有变更
};

#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;
}

#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>{

问题2：接口暴露理解

当前继承方式下，基类 vector<int> 的接口会自动成为 GradeCalc 的接口吗？如在 test 模块中这样用，能否编译通过？用一句话解释原因。

答:不会，不能，私有继承将基类std::vector<int>的公有成员push_back变为GradeCalc的私有成员，外部对象无法直接访问这些私有成员。

问题3：数据访问差异

对比继承方式与组合方式内部实现数据访问的一行典型代码。说明两种方式下的封装差异带来的数据访问接口差异。

答:组合:for(auto grade : grades)grades 是一个私有成员对象，必须通过显式命名访问；

    继承:for(int grade : *this)利用从基类继承的接口，可以直接使用 this 指针进行访问；

问题4：组合 vs. 继承方案选择

你认为组合方案和继承方案，哪个更适合成绩计算这个问题场景？简洁陈述你的结论和理由。

答:我认为组合更合适。因为成绩计算器和成绩列表属于"有一个"的关系。

 

Task3

1.源代码:

#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);  // 创建图形，返回堆对象指针

#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;
    }
}

#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 { ... };

问题2：多态机制观察

（1） Graph 中的 draw 若未声明成虚函数， Canvas::paint() 中 g->draw() 运行结果会有何不同？

答:将会始终调用 Graph 基类的 draw() 函数，无法实现多态，所有图形都只会输出相同内容甚至无输出。

（2）若 Canvas 类 std::vector<Graph*> 改成 std::vector<Graph> ，会出现什么问题？

答:调用 draw() 时无法实现多态，全部退化为 Graph 行为。因为 Graph 是基类，当把 Circle 对象存入 vector<Graph> 时，只会拷贝基类部分，丢失派生类特性。

（3）若 ~Graph() 未声明成虚函数，会带来什么问题？

答:删除 Graph* 指针时，只会调用基类析构函数，不会调用派生类的析构函数，空间不会得到释放，导致内存泄露。

问题3：扩展性思考

若要新增星形 Star ，需在哪些文件做哪些改动？逐一列出。

答:Graph.hpp: 在 enum class GraphType 中添加新类star;声明新类。


    Graph.cpp:实现 Star::draw() 函数; 在str_to_GraphType函数中新增Star字符串转换为枚举类型功能 ；在make_graph函数中返回star类型的堆指针。

问题4：资源管理

观察 make_graph 函数和 Canvas 析构函数：

（1） make_graph 返回的对象在什么地方被释放？

答:在 Canvas 类的析构函数 ~Canvas() 中被逐一释放。即：for (Graph* g : graphs) delete g;

（2）使用原始指针管理内存有何利弊？

答：利:可以直接操作内存地址，直观控制内存生命周期。

 　　弊:容易造成内存泄漏（忘记 delete）。

 

Task4

1.场景描述:

设计一个电子毛绒玩具工厂，生产具备"特异功能"的电子毛绒玩具:音乐熊、故事兔、闪光猫、汪汪狗。每种玩具都共同属性(名字、类型)，也有各自的特性。可以通过工厂模式对这些玩具进行统一管理；用多态调用它们各自的特异功能；用组合与继承建立对象关系，最后通过统一的接口(。perform())让所有玩具依次展示它们的特异功能。

 2.对象关系设计以及理由

类名	关系	说明
Toy	基类	定义通用接口.perform()和基本属性
Bear,Rabbit,Cat,Puuppy	继承Toy	具体子类，实现个性化功能
ToyFactory	组合std::vector<Toy*>	包含多个玩具对象，提供统一管理和展示功能

 

 

 

 

 

 理由:

继承:Bear,Rabbit,Cat,Puuppy是一种Toy,适合公有继承。

多态:通过虚函数 .perform() 实现运行时动态绑定，不同玩具表现不同行为。

组合:ToyFactory(has-a)Toy对象，体现“工厂拥有多个玩具”的关系。

 3.源代码:

#pragma once
#include <iostream>
#include <string>
#include <vector>

class Toy {
public:
    Toy(const std::string& name, const std::string& type);
    virtual ~Toy() = default;

    virtual void perform() const = 0;

    const std::string& getName() const;
    const std::string& getType() const;

protected:
    std::string name;
    std::string type;
};

class Bear : public Toy {
public:
    Bear();
    void perform() const override;
};

class Rabbit : public Toy {
public:
    Rabbit();
    void perform() const override;
};

class Cat : public Toy {
public:
    Cat();
    void perform() const override;
};

class Puppy : public Toy {
public:
    Puppy();
    void perform() const override;
};


class ToyFactory {
public:
    void add(Toy* toy);
    void showAllInfo() const;         // 显示所有玩具信息
    void tryAllSpecialAbilities() const; // 统一调用特异功能
    ~ToyFactory();

private:
    std::vector<Toy*> toys;
};

#include "Toy.hpp"

Toy::Toy(const std::string& name, const std::string& type): name(name), type(type) {}

const std::string& Toy::getName() const { return name; }
const std::string& Toy::getType() const { return type; }

Bear::Bear() : Toy("音乐熊", "毛绒发声玩具") {}
void Bear::perform() const {
    std::cout << "[" << name << "] 开始播放儿歌：《小星星》\n";
}

Rabbit::Rabbit() : Toy("故事兔", "教育玩具") {}
void Rabbit::perform() const {
    std::cout << "[" << name << "] 讲述睡前故事：《龟兔赛跑》\n";
}

Cat::Cat() : Toy("闪光猫", "LED光效玩具") {}
void Cat::perform() const {
    std::cout << "[" << name << "] 眼睛闪烁蓝光，进入梦幻模式\n";
}

Puppy::Puppy() : Toy("汪汪狗", "互动玩具") {}
void Puppy::perform() const {
    std::cout << "[" << name << "] 模仿小狗叫：汪!汪!汪！\n";
}

void ToyFactory::add(Toy* toy) {
    if (toy) toys.push_back(toy);
}

void ToyFactory::showAllInfo() const {
    std::cout << "\n=== 玩具工厂库存清单 ===\n";
    for (const auto* toy : toys) {
        std::cout << "- 名称：" << toy->getName()
                  << " | 类型：" << toy->getType() << "\n";
    }
    std::cout << "总计 " << toys.size() << " 个玩具。\n\n";
}

void ToyFactory::tryAllSpecialAbilities() const {
    std::cout << "正在逐一测试每个玩具的特异功能\n\n";
    for (const auto* toy : toys) {
        toy->perform();
    }
    std::cout << "\n所有玩具的功能测试完毕！\n";
}

ToyFactory::~ToyFactory() {
    for (auto* toy : toys) {
        delete toy;
    }
    toys.clear();
}

#include "Toy.hpp"

void test() {
    ToyFactory factory;

    factory.add(new Bear);
    factory.add(new Rabbit);
    factory.add(new Cat);
    factory.add(new Puppy);

    factory.showAllInfo();

    factory.tryAllSpecialAbilities();
}

int main() {
    test();
    return 0;
}

4.运行截图: