实验4

实验1

代码

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::string course_name;
std::vector<int> grades;
std::array<int, 5> counts;
std::array<double, 5> rates;

问题2

不合法。

push_back(97) 是 std::vector<int> 的成员函数，但 grades 是 GradeCalc 类的私有成员,GradeCalc 未在公有接口中暴露 push_back 方法，外部无法直接操作 grades 容器。

问题3

(1) compute() 调用1次。第一次调用 info() 时，is_dirty=true 会触发 compute() 并重置 is_dirty=false。后续两次调用因 is_dirty=false 直接使用缓存结果，跳过 compute()。is_dirty 的作用：标记成绩数据是否变更，避免重复计算统计信息，提升性能。

(2) 不需要更改 compute() 的调用位置。在 update_grade 中修改成绩后，只需设置 is_dirty=true。后续调用 info() 时，is_dirty 会触发重新计算。

问题4

实现方式：在 info() 中临时计算中位数。

修改位置：info() 函数。
伪代码：
void GradeCalc::info() {
if (is_dirty) compute(); // 确保统计信息最新
// ... 原有输出逻辑 ...

// 计算中位数（新增部分）
if (grades.empty()) {
std::cout << "中位数: 无成绩\n";
} else {
std::vector<int> temp = grades; // 复制成绩（避免修改原顺序）
std::sort(temp.begin(), temp.end()); // 升序排序
size_t n = temp.size();
double median = (n % 2 == 1)
? temp[n/2] // 奇数：取中间值
: (temp[n/2-1] + temp[n/2]) / 2.0; // 偶数：取中间两数均值
std::cout << "中位数: " << median << "\n";
}
}

问题5

不能去掉。若成绩变更后多次调用 compute()，未清零的 counts 会在原有基础上继续累加，导致统计值错误。例如：第一次录入成绩 [80, 90]，counts[3]=1。修改成绩为 [70, 85] 后再次调用 compute(),若未清零，counts[3] 会从1开始累加，结果变为2。

问题6

(1)无功能影响。程序仍能正常运行。

(2) 对性能有负面影响。当 n 较大时，vector可能因多次重新分配内存以及复制数据导致性能下降。

实验2

代码

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

不会，由于是私有继承（private），基类 vector<int> 的所有成员（包括 push_back）在 GradeCalc 中变为 private，外部无法直接访问。

问题3

for (auto grade : grades) // 直接访问私有成员
需通过公有接口暴露数据，封装性强，外部访问受限。

for (int grade : *this) // 通过基类迭代器访问
在类内部可直接使用基类接口，但私有继承隐藏基类接口，外部无法访问。

组合：完全控制数据暴露，需显式提供访问接口。
私有继承：基类接口仅在派生类内部可用，外部完全隐藏，但派生类可直接复用基类实现。

问题4

如果不需要考虑后续的话，继承更方便。零开销接口复用，直接继承vector的方法实现，无需包装转发；数据访问可以直接使用，容器操作可以直接继承。

实验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;

    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;（位于 Canvas 类中）
功能：存储动态创建的图形对象指针（Circle、Triangle、Rectangle），实现 Canvas 对多个图形对象的聚合管理。

(2) 继承关系
代码行：

class Circle : public Graph;
class Triangle : public Graph;
class Rectangle : public Graph;
说明：Circle、Triangle、Rectangle 均公开继承自基类 Graph。

问题2

(1) 未声明虚函数 draw 的结果
若 Graph::draw 未声明为虚函数，Canvas::paint() 中的 g->draw() 会始终调用基类 Graph::draw。输出结果：无任何图形绘制信息。

(2) 修改为 std::vector<Graph> 的问题
若使用 std::vector<Graph>，则添加派生类对象到容器时发生对象切片，派生类部分被截断。g.draw() 只能调用 Graph::draw，无法触发多态，且因 new 返回的派生类指针无法存入基类对象容器，无法正确释放内存。

(3) 未声明虚析构函数 ~Graph() 的问题
若 ~Graph() 非虚函数，则通过基类指针 delete 派生类对象时，派生类析构函数不会被调用，若派生类持有资源，会导致资源泄漏。

问题3

Graph.hpp

扩展枚举：enum class GraphType { circle, triangle, rectangle, star };
声明新类：

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

Graph.cpp

实现 Star::draw：

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

扩展 str_to_GraphType：

if (t == "star") return GraphType::star;

扩展 make_graph make_graph：

case GraphType::star: return new Star;

问题4

(1) 对象释放位置

make_graph 返回的堆对象在 Canvas 的析构函数中释放：
Canvas::~Canvas() {
for (Graph* g : graphs) delete g; // 释放所有图形对象
}
(2) 原始指针管理内存的利弊

利：直接控制内存分配/释放，无额外性能开销。

弊：易导致内存泄漏或重复释放，若 new 和 delete 之间抛出异常，内存泄漏。

实验4

场景描述

设计一个电子毛绒玩具管理系统，通过组合、继承和虚函数实现多态特性，允许通过统一接口调用不同玩具的特异功能。

对象关系

原因：通过虚函数和继承，实现了统一接口调用不同玩具的特异功能，系统易于添加新的玩具类型，只需继承Toy基类并实现specialFunction内存管理；工厂类负责集中管理所有玩具对象的内存释放；每个类职责明确，玩具实现细节对工厂类透明这种设计符合开放-封闭原则，新增玩具类型无需修改现有工厂逻辑，通过统一接口实现多态调用，具有良好的扩展性和可维护性。

代码

demo4.cpp

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

void test() {
    ToyFactory factory;
    
    // 创建不同类型的玩具
    factory.addToy(new TalkingToy("Lv Shi Han", "XiHuan Chang Tiao Rap LanQiu Music ~"));
    factory.addToy(new DancingToy("Cai Xukun", "Jasmine"));
    factory.addToy(new SingingToy("Kun Kun", "I\'m a dead man ~~~"));
    factory.addToy(new DancingToy("KUN", "鸡你太美"));
    factory.addToy(new TalkingToy("Li Zhi", "香翅捞饭，食不食油饼"));
    
    // 显示所有玩具信息
    factory.displayAllToys();
    
    // 激活所有玩具的特异功能
    factory.activateAllFunctions();
}

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

ToyFactory.cpp

#include "ToyFactory.hpp"

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

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

void ToyFactory::displayAllToys() const {
    std::cout << "\n=== Toy Collection ===\n";
    for (const Toy* toy : toys) {
        toy->displayInfo();
        std::cout << "--------------------\n";
    }
}

void ToyFactory::activateAllFunctions() const {
    std::cout << "\n=== Activating All Toys ===\n";
    for (const Toy* toy : toys) {
        std::cout << toy->getName() << ": ";
        toy->specialFunction();
    }
}

ToyFactory.hpp

#ifndef TOY_FACTORY_HPP
#define TOY_FACTORY_HPP

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

class ToyFactory {
private:
    std::vector<Toy*> toys;
    
public:
    ~ToyFactory();
    void addToy(Toy* toy);
    void displayAllToys() const;
    void activateAllFunctions() const;
};

#endif

SpecializedToys.cpp

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

TalkingToy::TalkingToy(const std::string& name, const std::string& phrase)
    : Toy(name, "Talking Toy"), phrase(phrase) {}

void TalkingToy::specialFunction() const {
    std::cout << "Says: \"" << phrase << "\"\n";
}

DancingToy::DancingToy(const std::string& name, const std::string& danceStyle)
    : Toy(name, "Dancing Toy"), danceStyle(danceStyle) {}

void DancingToy::specialFunction() const {
    std::cout << "Performs " << danceStyle << " dance\n";
}

SingingToy::SingingToy(const std::string& name, const std::string& song)
    : Toy(name, "Singing Toy"), song(song) {}

void SingingToy::specialFunction() const {
    std::cout << "Sings: \"" << song << "\"\n";
}

SpecializedToys.hpp

#ifndef SPECIALIZED_TOYS_HPP
#define SPECIALIZED_TOYS_HPP

#include "Toy.hpp"

// 会说话的玩具
class TalkingToy : public Toy {
private:
    std::string phrase;
    
public:
    TalkingToy(const std::string& name, const std::string& phrase);
    void specialFunction() const override;
};

// 会跳舞的玩具
class DancingToy : public Toy {
private:
    std::string danceStyle;
    
public:
    DancingToy(const std::string& name, const std::string& danceStyle);
    void specialFunction() const override;
};

// 会唱歌的玩具
class SingingToy : public Toy {
private:
    std::string song;
    
public:
    SingingToy(const std::string& name, const std::string& song);
    void specialFunction() const override;
};

#endif

Toy.cpp

#include "Toy.hpp"

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

void Toy::displayInfo() const {
    std::cout << "Name: " << name << "\nType: " << type << "\n";
}

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

Toy.hpp

#ifndef TOY_HPP
#define TOY_HPP

#include <string>
#include <iostream>

class Toy {
protected:
    std::string name;
    std::string type;
    
public:
    Toy(const std::string& name, const std::string& type);
    virtual ~Toy() = default;
    
    virtual void specialFunction() const = 0;  // 纯虚函数
    virtual void displayInfo() const;
    
    std::string getName() const;
    std::string getType() const;
};

#endif

截图

posted @ 2025-12-03 01:38 NolanNiko 阅读(0) 评论(0) 收藏举报

刷新页面返回顶部