实验四

任务1

源代码

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

GradeClac.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;
    if (grades.empty())
        std::cout << "中位数:\t" << 0.0 << '\n';
    std::vector<int> temp = grades;
    std::sort(temp.begin(), temp.end());
    if (grades.size() % 2 == 1)
    {
        std::cout << "中位数:\t" << static_cast<double>(temp[grades.size() / 2]) << '\n';
    }
    else
    {
        std::cout << "中位数:\t" <<  static_cast<double>((temp[grades.size() / 2 - 1] + temp[grades.size() / 2]) / 2.0) << '\n';
    }
    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::array<int, 5> counts;
std::array<double, 5> rates;
std::string course_name;
std::vector grades;
course_name保存课程名

grades保存课程成绩

rates用数组保存各分数段人数占比。

counts用数组保存各分数段人数

问题2：接口暴露理解

当前继承方式下，基类vector的接口会自动成为GradeCalc的接口吗？

如在test模块中这样用，能否编译通过？用一句话解释原因。

 不合法，因为push_back 使vector类型中在尾部增加元素的，但是vector类型的grades是私有成员，无法通过外部接口访问

问题3：数据访问差

问题3：架构设计分析

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

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

compute()只会被调用一次，is_dirty标记用于显示成绩是否被更改，只有检测到成绩被更改才会调用compute()。

 

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

不需要，因为新增函数只要在函数体内部更改了 is_dirty ，就会在info模块中调用compute，无需重新更改位置

问题4：功能扩展设计

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

可以在info()函数里加。
if grades为0
cout<<"中位数="<<0.0
vector temp = grades;
sort(temp.begin(),temp.end())
if grades.size()不能被2整除
cout<<"中位数="<<temp[grades.size()/2]
else
cout<<"中位数="<<avg(temp[grades.size()/2-1],temp[grades.size()/2])

 

 

问题5：数据状态管理

GradeCalc 和 compute 中都包含代码： counts.fill(0); rates.fill(0); 。

compute 中能否去掉这两行？如去掉，在哪种使用场景下会引发统计错误？

不能去掉这两行，在成绩数据变化并且compute被多次调用的时候会引发统计错误。

 

 

问题6：内存管理理解

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

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

对程序功能没有影响。

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

对性能有影响。提前分配vector空间，避免多次push_back造成的多次扩容。

 

 

任务2

源代码

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

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 模块中这样用，能否编译通过？用一句话解释原因。

不会，继承方式时private私有继承，vector内部的的接口不能在外部被调用

问题3：数据访问差异

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

 1.组合：通过grade直接迭代vector类的grades

2.继承：通过继承了vector接口的*this来迭代

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

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

组合，因为成绩计算类包含存储成绩的成员，是包含has a 的关系，符合组合，而不是范围大小is a 的关系。

任务3

源代码

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;

#include <string>
#include "Graph.hpp"

void test() {
    Canvas canvas;

    canvas.add("circle");
    canvas.add("triangle");
    canvas.add("rectangle");
    canvas.paint();
}

int main() {
    test();
}

 

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

运行测试结果

 

问题1：对象关系识别

（1）写出Graph.hpp中体现"组合"关系的成员声明代码行，并用一句话说明被组合对象的功能。

std::vector<Graph*> graphs; 通过vector类型的多个graphs成员组合存储了多个Graph*对象。存储所需要绘制的图形们

（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()没有被重写，用基类Graph指针调用时，被调用的是Graph中不做任何操作的draw()。

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

Graph是抽象类，不可以直接创建对象，会导致编译失败

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

如果Graph()没有声明为虚函数，则不会在运行期根据对象实际类型调用对应的析构函数。派生类如果包含动态分配的资源，但调用的是基类的析构函数，则会导致内存泄漏。

 

问题3：扩展性思考

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

1.hpp文件中

新增枚举类型star  enum class GraphType {circle, triangle, rectangle，star};

新增class Star :public Graph {public :void draw();};

2.cpp文件

新增void Star ::draw(){std::cout<<"draw a star..\n";}

str_to_GraphType中新增if（t =="star")return GraphType::star;

make_graph中switch新增case  GraphType::star:return new Star;

3.demo3.cpp

void test()新增canvas.add（“star”)；

 

问题4：资源管理

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

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

在canvas析构函数遍历graphs对每个指针释放内存

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

优点：可以将继承自基类的不同派生类存放在一起，并且可以用基类指针进行批量管理，操作便捷。
缺点：用new分配的内存空间，如果没有delete，会导致内存泄漏；重复delete或者调用前被误释放，会产生野指针。必须通过Graph指针访问，不能直接访问派生类的特有成员。析构函数若为非虚函数，析构时会导致内存泄漏。

 

任务4

源代码

Toy.hpp

 

#pragma once
#include <string>

enum class ToyType
{
    UNKNOWNTOY,
    DOG,
    CAT,
    BEAR,
};

class Toy
{
public:    
    Toy(const std::string& name0 = "Default Name", const std::string& material0 = "Default Material", const std::string& musicAudio0 = "DefaultSong");
    virtual ~Toy();

    virtual void start() = 0;
    virtual void act() = 0;
    virtual void playAudio() = 0;
    virtual void shutdown() = 0;
    void displayInfo();

    const std::string& getName() const { return name; }
protected:
    std::string name;
    std::string material;
    std::string musicAudio;
    ToyType type;
};

Toy.cpp

 

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


Toy::Toy(const std::string& name0, const std::string& material0, const std::string& musicAudio0) :
    name{ name0 }, material{ material0 }, musicAudio{ musicAudio0 }, type{ToyType::UNKNOWNTOY} { }

Toy::~Toy() = default;

void Toy::displayInfo()
{
    std::cout << name << '\t' << material << '\t';
    switch (type)
    {
    case ToyType::DOG:
        std::cout << "Dog\t";
        break;
    case ToyType::CAT:
        std::cout << "Cat\t";
        break;
    case ToyType::BEAR:
        std::cout << "Bear\t";
        break;
    default:
        std::cout << "Unknown Type\t";
    }
    std::cout << musicAudio << "\n";
}

DogToy.hpp

 

#pragma once
#include "Toy.hpp"

class DogToy : public Toy
{
public:
    DogToy(const std::string& name0 = "FriendDog", const std::string& material0 = "Cotton", const std::string& musicAudio = "DefaultDogSong");
    
    void start() override;//override表示这个函数是重写基类的虚函数，需要检查参数、返回值等是否匹配
    void act() override;
    void playAudio() override;
    void shutdown() override;

private:
    void Shout();
    static constexpr const char* shoutAudio = "Woof!";
};

DogToy.cpp

 

#include "DogToy.hpp"
#include <iostream>

DogToy::DogToy(const std::string& name0, const std::string& material0, const std::string& musicAudio0) : Toy(name0,material0,musicAudio0)
{
    type = ToyType::DOG;
}

void DogToy::start()
{
    std::cout << "Hi! My name is " << name << ". Let's play! ";
    Shout();
    std::cout << std::endl;
}

void DogToy::act()
{
    std::cout << name << " is wagging tail!\n";
}

void DogToy::playAudio()
{
    std::cout << "Playing: " << musicAudio << '\n';
}


void DogToy::shutdown()
{
    std::cout << "Bye! ";
    Shout();
    std::cout << '\n';
}

void DogToy::Shout()
{
    std::cout << shoutAudio;
}

CatToy.hpp

 

#pragma once
#include "Toy.hpp"

class CatToy : public Toy
{
public:
    CatToy(const std::string& name0 = "FriendCat", const std::string& material0 = "Cotton", const std::string& musicAudio = "DefaultCatSong");

    void start() override;
    void act() override;
    void playAudio() override;
    void shutdown() override;

private:
    void Shout();
    static constexpr const char* shoutAudio = "Meow!";
};

CatToy.cpp

 

#include "CatToy.hpp"
#include <iostream>

CatToy::CatToy(const std::string& name0, const std::string& material0, const std::string& musicAudio0) : Toy(name0, material0, musicAudio0)
{
    type = ToyType::CAT;
}

void CatToy::start()
{
    std::cout << "Hi! My name is " << name << ". Let's play! ";
    Shout();
    std::cout << std::endl;
}

void CatToy::act()
{
    std::cout << name << " is licking its fur!\n";
}

void CatToy::playAudio()
{
    std::cout << "Playing: " << musicAudio << '\n';
}


void CatToy::shutdown()
{
    std::cout << "Bye! ";
    Shout();
    std::cout << '\n';
}

void CatToy::Shout()
{
    std::cout << shoutAudio;
}

BearToy.hpp

#pragma once
#include "Toy.hpp"

class BearToy : public Toy
{
public:
    BearToy(const std::string& name0 = "FriendBear", const std::string& material0 = "Cotton", const std::string& musicAudio = "DefaultBearSong");

    void start() override;
    void act() override;
    void playAudio() override;
    void shutdown() override;

};

BearToy.cpp

 

#include "BearToy.hpp"
#include <iostream>

BearToy::BearToy(const std::string& name0, const std::string& material0, const std::string& musicAudio0) : Toy(name0, material0, musicAudio0)
{
    type = ToyType::BEAR;
}

void BearToy::start()
{
    std::cout << "Hi! My name is " << name << ". Let's play! ";
    std::cout << std::endl;
}

void BearToy::act()
{
    std::cout << name << " is waving its hands!\n";
}

void BearToy::playAudio()
{
    std::cout << "Playing: " << musicAudio << '\n';
}


void BearToy::shutdown()
{
    std::cout << "Bye! ";
    std::cout << '\n';
}

ToyFactory.hpp

 

#include "Toy.hpp"
#include "BearToy.hpp"
#include "DogToy.hpp"
#include "CatToy.hpp"
#include <string>
#include <vector>
class ToyFactory
{
public:
    ToyFactory(const std::string& title0);
    ~ToyFactory();
    void display() const;
    void act() const;
    void play() const;
    void addToy(const std::string& type0 = "unknowntoy", const std::string& name0 = "Default Name",
        const std::string& material0 = "Default Material", const std::string& musicAudio0 = "DefaultSong");
    void delToy(const std::string& target);

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

ToyType str_to_ToyType(const std::string& s);

ToyFactory.cpp

#include "ToyFactory.hpp"
#include <algorithm>
#include <cctype>
#include <iostream>

ToyFactory::ToyFactory(const std::string& title0) : title{title0} { }
ToyFactory::~ToyFactory()
{
    for (Toy* t : toys)
        delete t;
}
ToyType str_to_ToyType(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 == "dog")
        return ToyType::DOG;
    if (t == "cat")
        return ToyType::CAT;
    if (t == "bear")
        return ToyType::BEAR;
    return ToyType::UNKNOWNTOY;
}

void ToyFactory::display() const
{
    std::cout << "Toys Informaiton: \n";
    if (toys.size() == 0)
    {
        std::cout << "factory is empty!";
        return;
    }
    Toy* index = toys.at(0);
    for (int i = 0; i < toys.size(); i++)
    {
        index = toys.at(i);
        index->displayInfo();
    }
}

void ToyFactory::act() const
{
    for (auto i : toys)
        i->act();
}

void ToyFactory::play() const
{
    for (auto i : toys)
        i->playAudio();
}

void ToyFactory::addToy(const std::string& type0, const std::string& name0, const std::string& material0, const std::string& musicAudio0)
{
    for (Toy* t : toys)
    {
        if (t->getName() == name0)
        {
            std::cerr << name0 << " has existed!\n";
            return;
        }
    }
    Toy* newToy;
    switch (str_to_ToyType(type0))
    {
    case ToyType::DOG:
        newToy = new DogToy(name0, material0, musicAudio0);
        break;
    case ToyType::CAT:
        newToy = new CatToy(name0, material0, musicAudio0);
        break;
    case ToyType::BEAR:
        newToy = new BearToy(name0, material0, musicAudio0);
        break;
    default:
        std::cerr << "Fail To Add Toy: " << name0 << " Unknown Type\n";
        return;
        
    }
    toys.push_back(newToy);
    std::cout << "Success To Add Toy: " << name0 << '\n';
}

void ToyFactory::delToy(const std::string& target)
{
    for (auto it = toys.begin(); it != toys.end(); it++)
    {
        if (*it && (*it)->getName() == target)
        {
            delete* it;
            toys.erase(it);
            std::cout << "Del Success\n";
            return;
        }
    }
    std::cerr << "target not found";
}

main.cpp

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

void test1()
{
    ToyFactory factory("My Toy Factory");
    factory.addToy("cat", "kitty", "cotton", "MorningMeow");
    factory.addToy("DOG", "Bruce", "Plastic", "Erica");
    factory.addToy("Bear", "Teddy", "Cotton", "Hotel California");
    factory.display();
    factory.act();
    factory.play();
    factory.delToy("kitty");
    factory.display();
}

int main()
{
    test1();
}

 

运行结果截图