实验4 组合与继承

##实验一

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

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

image

 

 问题一：

std::string course_name:存储课程名称。std::vector<int> grades:存储所有学生的成绩数据。std::array<int,5> counts:存储5个分数段的人数统计。

std::array<double,5> rates:固定存储5个分数段的占比率并进行分析。bool is_dirty:脏标记。

问题二：不合法 因为在函数中它们是组合关系，不可以直接调用。

问题三：1.  1次  避免重复计算，节约运算时间，提高效率。

2.   不需要，只修改某一条记录的分数，并不直接触发成绩统计逻辑.

问题四：在info（）加入

void compute() {
   
    float median = 0.0f;
    int n = grades.size();
    
    if (n > 0) {
        
        std::vector<float> sortedGrades = grades;
        std::sort(sortedGrades.begin(), sortedGrades.end());
        
        if (n % 2 == 1) {
            median = sortedGrades[n / 2];
        } else {
            median = (sortedGrades[n / 2 - 1] + sortedGrades[n / 2]) / 2.0f;
        }
    }
    
   
}

问题五：不能  在数据重新写进时，可能与原数据抵触，而报错。

问题六： 1.无影响 2.有影响，会减低代码的运算性能。

 

##实验二

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

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

 问题一：class GradeCalc: private std::vector<int> 

问题二：会   基类vector<int>的所有公有成员都会成为派生类GradeCalc的公有接口。

问题三：前者为组合方式  后者为继承方式
问题四：我认为组合方式更好，封装性更好。接口最小化只暴露必要的成绩计算方法，不会暴露vector的所有方法。。

 

##实验三
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();
}

image

 问题一：1.std::vector<Graph*> graphs;   存储指向各种图形对象的指针。2.class Circle : public Graph        class Triangle : public Graph       class rectangle : public Graph 

问题二：1.所有图形只能按基类方式绘制。2.所有派生类对象都被"切割"为基类对象无法访问派生类的特有方法和属性。3.内存泄漏。

问题三：在GraphType枚举中添加star成员。

问题四：1.Canvas的析构函数。

2.利：性能最好，兼容性与灵活性好，弊端：内存泄漏，指向不明，异常，容易出错等。

##实验四

image

 

 





#ifndef TOY_HPP
#define TOY_HPP

#include <string>
#include <iostream>

class Toy {
protected:
    std::string name;
    std::string type;
    double price;
    std::string color;
    int batteryLevel;
    
public:
    Toy(const std::string& n, const std::string& t, double p, const std::string& c);
    virtual ~Toy() = default;
    
    virtual void showInfo() const;
    virtual void specialFunction() = 0;
    virtual void interact() = 0;
    
    std::string getName() const;
    std::string getType() const;
    double getPrice() const;
    std::string getColor() const;
    int getBatteryLevel() const;
    
    void setName(const std::string& n);
    void setPrice(double p);
    void setColor(const std::string& c);
    void chargeBattery(int amount);
    
    bool hasBattery() const;
};

#endif








#include "toy.hpp"

Toy::Toy(const std::string& n, const std::string& t, double p, const std::string& c)
    : name(n), type(t), price(p), color(c), batteryLevel(100) {}

void Toy::showInfo() const {
    std::cout << "名称: " << name 
              << " | 类型: " << type 
              << " | 价格: ￥" << price 
              << " | 颜色: " << color 
              << " | 电量: " << batteryLevel << "%" << std::endl;
}

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

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

double Toy::getPrice() const {
    return price;
}

std::string Toy::getColor() const {
    return color;
}

int Toy::getBatteryLevel() const {
    return batteryLevel;
}

void Toy::setName(const std::string& n) {
    name = n;
}

void Toy::setPrice(double p) {
    price = p;
}

void Toy::setColor(const std::string& c) {
    color = c;
}

void Toy::chargeBattery(int amount) {
    batteryLevel += amount;
    if (batteryLevel > 100) batteryLevel = 100;
}

bool Toy::hasBattery() const {
    return batteryLevel > 0;
}






#ifndef SINGINGBEAR_HPP
#define SINGINGBEAR_HPP

#include "toy.hpp"

class SingingBear : public Toy {
private:
    int songCount;
    bool canDance;
    int volumeLevel;
    
public:
    SingingBear(const std::string& name, double price, const std::string& color);
    
    void showInfo() const override;
    void specialFunction() override;
    void interact() override;
    
    void playSong();
    void toggleDance();
    void adjustVolume(int level);
    void addSong();
    
    int getSongCount() const;
    bool getDanceStatus() const;
    int getVolumeLevel() const;
};

#endif






#include "singingBear.hpp"
#include <cstdlib>
#include <ctime>

SingingBear::SingingBear(const std::string& name, double price, const std::string& color)
    : Toy(name, "唱歌熊", price, color), songCount(5), canDance(true), volumeLevel(50) {}

void SingingBear::showInfo() const {
    Toy::showInfo();
    std::cout << "  歌曲数量: " << songCount 
              << " | 舞蹈功能: " << (canDance ? "有" : "无")
              << " | 音量: " << volumeLevel << std::endl;
}

void SingingBear::specialFunction() {
    if (hasBattery()) {
        std::cout << name << " 启动唱歌模式！" << std::endl;
        playSong();
        if (canDance) {
            std::cout << name << " 开始跳舞！" << std::endl;
        }
    } else {
        std::cout << name << " 电量不足，请充电！" << std::endl;
    }
}

void SingingBear::interact() {
    std::cout << name << " 说：你好！我是会唱歌的小熊！" << std::endl;
    playSong();
}

void SingingBear::playSong() {
    srand(time(0));
    int songNum = rand() % songCount + 1;
    std::cout << name << " 正在播放第 " << songNum << " 首歌曲..." << std::endl;
    batteryLevel -= 5;
}

void SingingBear::toggleDance() {
    canDance = !canDance;
    std::cout << name << " 舞蹈功能: " << (canDance ? "开启" : "关闭") << std::endl;
}

void SingingBear::adjustVolume(int level) {
    volumeLevel = level;
    if (volumeLevel < 0) volumeLevel = 0;
    if (volumeLevel > 100) volumeLevel = 100;
    std::cout << name << " 音量调整为: " << volumeLevel << std::endl;
}

void SingingBear::addSong() {
    songCount++;
    std::cout << name << " 添加了新歌曲，现在有 " << songCount << " 首歌曲" << std::endl;
}

int SingingBear::getSongCount() const {
    return songCount;
}

bool SingingBear::getDanceStatus() const {
    return canDance;
}

int SingingBear::getVolumeLevel() const {
    return volumeLevel;
}






继承关系




ToyFactory (玩具工厂)── std::vector<Toy*> toys (管理多个玩具对象)提供统一的管理接口
每个Toy对象内部：基本属性：name, type, price, color态属性：batteryLevel




    

  • 

    ToyFactory组合Toy对象：使用 std::vector<Toy*> 存储玩具指针。通过指针实现多态调用。工厂负责管理玩具的生命周期
    

    • 

  • 

    Toy类的属性组合：玩具包含基本属性（名称、类型、价格、颜色）。包含状态属性（电池电量）。这些属性通过组合方式构成完整的玩具对象。 
    

    • 



 










            

            
posted @ 
2025-12-02 22:34 
石朗鹏 
阅读(0) 
评论(0) 
 
收藏 
举报