OOP-实验4

实验任务1

源代码 GradeCalc.hpp,GradeCalc.cpp,task1.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; // 更新脏标记
}

点击查看代码 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();
}

运行测试截图

• 问题1：组合关系识别
  GradeCalc类声明中，逐行写出所有体现"组合"关系的成员声明，并用一句话说明每个被组合对象的功能。

• 回答：std::vector<int> grades;记录课程成绩；std::array<int, 5> counts;记录各分数段人数；std::array<double, 5> rates;记录各分数段人数百分比。

• 问题2：接口暴露理解
  如在test模块中这样使用，是否合法？如不合法，解释原因。

GradeCalc c("OOP");
c.inupt(5);
c.push_back(97); // 合法吗？

• 回答：不合法，GradeCalc中未实现push_back方法。

• 问题3：架构设计分析
  当前设计方案中，compute在info模块中调用：

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

• 回答：compute被调用1次，标记is_dirty避免对compute的不必要调用。

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

• 回答：不需要，调用update_grade(index, new_grade)时更新标记is_dirty，根据标记调用compute。

• 问题4：功能扩展设计
  要增加"中位数"统计，不新增数据成员怎么做？在哪个函数里加？写出伪代码。

• 回答：可在sort里添加

    int median;
    if (grades.size() % 2 == 0)
        median = (grades[grades.size() / 2] + grades[grades.size() / 2 - 1]) / 2;
    else
        median = grades[grades.size() / 2];

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

• 回答：不能去掉，若去掉，则当数据更新时会出现统计错误。

• 问题6：内存管理理解
  input模块中代码grades.reserve(n);如果去掉：

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

• 回答：对程序功能无影响。

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

• 回答：对性能有影响，当成绩条目比较多时，去掉grades.reserve(n);会频繁发生内存分配的现象。

实验任务2

源代码 GradeCalc.hpp,GradeCalc.cpp,task2.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;
}

点击查看代码 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();
}

运行测试截图

• 问题1：继承关系识别
  写出GradeCalc类声明体现"继承"关系的完整代码行。

• 回答：class GradeCalc : private std::vector<int>

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

    GradeCalc c("OOP");
    c.input(5);
    c.push_back(97); // 合法吗？

• 回答：vector<int>的接口会自动成为GradeCalc的接口。编译不能通过，因为GradeCalc是私有继承vector<int>，故push_back成为GradeCalc的私有接口。

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

// 组合方式
for (auto grade : grades) // 通过什么接口访问数据
    // 略
// 继承方式
for (int grade : *this)
    // 略

• 回答：组合方式通过vector<int>的迭代器访问数据，继承方式通过this指针访问数据。

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

• 回答：我认为组合方案更合适。其一，组合方案的成员组织逻辑更清晰；其二，对比组合方案，继承方案会继承对GradeCalc来说冗余的接口。

实验任务3

源代码 Graph.hpp,Graph.cpp,task3.cpp

点击查看代码 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();
}

运行测试截图

• 问题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()运行结果会有何不同？

• 回答：运行结果为空。

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

• 回答：需要相应修改涉及Graph *的代码，销毁对象时并不方便。

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

• 回答：无法通过基类指针删除派生类对象。

• 问题3：扩展性思考
  若要新增星形Star，需在哪些文件做哪些改动？逐一列出。

• 回答：在Graph.hpp中，enum class GraphType添加Star，添加类class Star : public Graph和公有接口draw声明；在Graph.cpp中，实现Star类接口draw定义。

• 问题4：资源管理
  观察make_graph函数和Canvas析构函数：

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

• 回答：Canvas的析构函数。

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

• 回答：利是避免指针类型转换，内存访问效率高；弊是非显示说明指针指向何种对象，不当使用产生的后果较为严重。

实验任务4

源代码 Toy.hpp,Toy.cpp,ToyFactory.hpp,ToyFactory.cpp,task4.cpp

点击查看代码 Toy.hpp

#pragma once

#include <iostream>
#include <string>

// 玩具基类
class Toy
{
public:
    Toy() = default;
    Toy(std::string _name, std::string _type, std::string _manufacturer,
        char _size, double _weight, double _price,
        int _recommendedAge, int _releaseYear);
    virtual ~Toy() = default;

    virtual void specialFunction() const = 0; // 特异功能
    virtual void displayInfo() const = 0;     // 显示玩具信息

protected:
    std::string name;         // 玩具名称
    std::string type;         // 玩具类型
    std::string manufacturer; // 制造商
    char size;                // 尺寸
    double weight;            // 重量
    double price;             // 价格
    int recommendedAge;       // 推荐年龄
    int releaseYear;          // 发布年份
};

// 泰迪熊类
class TeddyBear : public Toy
{
public:
    TeddyBear() = default;
    TeddyBear(std::string _name, std::string _type, std::string _manufacturer,
              char _size, double _weight, double _price,
              int _recommendedAge, int _releaseYear,
              std::string _furcolor, std::string _furMaterial);
    ~TeddyBear() override = default;

    void specialFunction() const override;
    void displayInfo() const override;

private:
    std::string furcolor;    // 毛发颜色
    std::string furMaterial; // 毛发材质
};

// 电子玩具类
class ElectronicToy : public Toy
{
public:
    ElectronicToy() = default;
    ElectronicToy(std::string _name, std::string _type, std::string _manufacturer,
                  char _size, double _weight, double _price,
                  int _recommendedAge, int _releaseYear,
                  std::string _powerSource, double _batteryLife);
    ~ElectronicToy() override = default;

    void specialFunction() const override;
    void displayInfo() const override;

private:
    std::string powerSource; // 电源类型
    double batteryLife;      // 电池寿命
};

// 互动玩具类
class InteractiveToy : public Toy
{
public:
    InteractiveToy() = default;
    InteractiveToy(std::string _name, std::string _type, std::string _manufacturer,
                   char _size, double _weight, double _price,
                   int _recommendedAge, int _releaseYear,
                   int _interactionLevel, std::string _interactionType);
    ~InteractiveToy() override = default;

    void specialFunction() const override;
    void displayInfo() const override;

private:
    int interactionLevel;        // 互动级别
    std::string interactionType; // 互动类型
};

点击查看代码 Toy.cpp

#include "Toy.hpp"

Toy::Toy(std::string _name, std::string _type, std::string _manufacturer,
         char _size, double _weight, double _price,
         int _recommendedAge, int _releaseYear)
    : name(std::move(_name)), type(std::move(_type)), manufacturer(std::move(_manufacturer)),
      size(_size), weight(_weight), price(_price),
      recommendedAge(_recommendedAge), releaseYear(_releaseYear) {}

TeddyBear::TeddyBear(std::string _name, std::string _type, std::string _manufacturer,
                     char _size, double _weight, double _price,
                     int _recommendedAge, int _releaseYear,
                     std::string _furcolor, std::string _furMaterial)
    : Toy(std::move(_name), std::move(_type), std::move(_manufacturer),
          _size, _weight, _price,
          _recommendedAge, _releaseYear),
      furcolor(std::move(_furcolor)), furMaterial(std::move(_furMaterial)) {}

void TeddyBear::specialFunction() const
{
    std::cout << "这是泰迪熊的功能" << std::endl;
}

void TeddyBear::displayInfo() const
{
    std::cout << "玩具信息：" << name << std::endl;
    std::cout << "类型：" << type << std::endl;
    std::cout << "制造商：" << manufacturer << std::endl;
    std::cout << "尺寸：" << size << std::endl;
    std::cout << "重量：" << weight << " kg" << std::endl;
    std::cout << "价格：¥" << price << std::endl;
    std::cout << "推荐年龄：" << recommendedAge << " 岁及以上" << std::endl;
    std::cout << "发布年份：" << releaseYear << " 年" << std::endl;
    std::cout << "毛发颜色：" << furcolor << std::endl;
    std::cout << "毛发材质：" << furMaterial << std::endl;
}

ElectronicToy::ElectronicToy(std::string _name, std::string _type, std::string _manufacturer,
                             char _size, double _weight, double _price,
                             int _recommendedAge, int _releaseYear,
                             std::string _powerSource, double _batteryLife)
    : Toy(std::move(_name), std::move(_type), std::move(_manufacturer),
          _size, _weight, _price,
          _recommendedAge, _releaseYear),
      powerSource(std::move(_powerSource)), batteryLife(_batteryLife) {}

void ElectronicToy::specialFunction() const
{
    std::cout << "这是电子玩具的功能" << std::endl;
}

void ElectronicToy::displayInfo() const
{
    std::cout << "玩具信息：" << name << std::endl;
    std::cout << "类型：" << type << std::endl;
    std::cout << "制造商：" << manufacturer << std::endl;
    std::cout << "尺寸：" << size << std::endl;
    std::cout << "重量：" << weight << " kg" << std::endl;
    std::cout << "价格：¥" << price << std::endl;
    std::cout << "推荐年龄：" << recommendedAge << " 岁及以上" << std::endl;
    std::cout << "发布年份：" << releaseYear << " 年" << std::endl;
    std::cout << "电源类型：" << powerSource << std::endl;
    std::cout << "电池寿命：" << batteryLife << " h" << std::endl;
}

InteractiveToy::InteractiveToy(std::string _name, std::string _type, std::string _manufacturer,
                               char _size, double _weight, double _price,
                               int _recommendedAge, int _releaseYear,
                               int _interactionLevel, std::string _interactionType)
    : Toy(std::move(_name), std::move(_type), std::move(_manufacturer),
          _size, _weight, _price,
          _recommendedAge, _releaseYear),
      interactionLevel(_interactionLevel), interactionType(std::move(_interactionType)) {}

void InteractiveToy::specialFunction() const
{
    std::cout << "这是互动玩具的功能" << std::endl;
}

void InteractiveToy::displayInfo() const
{
    std::cout << "玩具信息：" << name << std::endl;
    std::cout << "类型：" << type << std::endl;
    std::cout << "制造商：" << manufacturer << std::endl;
    std::cout << "尺寸：" << size << std::endl;
    std::cout << "重量：" << weight << " kg" << std::endl;
    std::cout << "价格：¥" << price << std::endl;
    std::cout << "推荐年龄：" << recommendedAge << " 岁及以上" << std::endl;
    std::cout << "发布年份：" << releaseYear << " 年" << std::endl;
    std::cout << "互动级别：" << interactionLevel << std::endl;
    std::cout << "互动类型：" << interactionType << std::endl;
}

点击查看代码 ToyFactory.hpp

#pragma once

#include <iostream>
#include <string>
#include <vector>
#include "Toy.hpp"

class ToyFactory
{
public:
    ToyFactory(const std::string &_name);
    ~ToyFactory();

    void addToy(Toy *toy);
    void displayAllToys() const;

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

点击查看代码 ToyFactory.cpp

#include "ToyFactory.hpp"

ToyFactory::ToyFactory(const std::string &_name) : name(_name) {}

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

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

void ToyFactory::displayAllToys() const
{
    std::cout << "玩具工厂：" << name << "的所有" << "（" << toys.size() << "个）" << "玩具信息如下：" << std::endl;
    std::cout << std::endl;
    int count = 1;
    for (const Toy *toy : toys)
    {
        std::cout << "第" << count++ << "个玩具信息：" << std::endl;
        toy->displayInfo();
        std::cout << "特异功能：";
        toy->specialFunction();
        std::cout << std::endl;
    }
}

点击查看代码 task4.hpp

#include <iostream>
#include "Toy.hpp"
#include "ToyFactory.hpp"

void test()
{
    ToyFactory factory("欢乐玩具厂");
    Toy *teddyBear = new TeddyBear("罗斯福熊", "泰迪熊", "玩具公司A", 'M', 0.5, 199.99, 3, 2020, "黄色", "绒毛");
    Toy *electronicToy = new ElectronicToy("遥控布偶", "电子玩具", "玩具公司B", 'L', 1.2, 299.99, 6, 2021, "电池", 2.5);
    Toy *interactiveToy = new InteractiveToy("智能交互玩偶", "互动玩具", "玩具公司C", 'M', 0.8, 499.99, 8, 2022, 5, "语音交互");
    factory.addToy(teddyBear);
    factory.addToy(electronicToy);
    factory.addToy(interactiveToy);
    factory.displayAllToys();
}
int main()
{
    test();
    return 0;
}

运行测试截图

应用问题场景描述

简化的玩具制造与库存管理模型

各类关系及设计理由

TeddyBear、ElectronicToy、InteractiveToy均继承自Toy，ToyFactory的成员包含Toy。前者采用继承方式，因为毛绒玩具类是抽象类，可针对特殊外观和功能等衍生出各种派生类；后者采用组合方式，使用vector组织Toy指针，方便通过基类指针统一访问派生类。

实验总结

• 在task4.cpp的test模块中，没有对Toy指针的销毁操作，是因为将此操作封装在ToyFactory的析构函数中。当然，在test模块中实现销毁指针，而在ToyFactory析构函数中不涉及销毁指针操作，应该也是可行的。不知二者孰优孰劣。

• xiǎo xióng wéi ní的xióng wéi ní在博客园上居然是敏感词？？？