OOP四

任务一：

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

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

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

运行结果：

屏幕截图 2025-12-02 193934

问题：

一：vector<int>grades  储存课程成绩

array<int,5>counts  统计5个分数段对应的人数

array<double,5>rates保存各分段人数占比

二：不合法，push_back不是类GradeCalc中的成员函数，而grades是私有成员，外部想要访问必须通过GradeCalc提供的公共接口

三：（1）仅被调用一次，is_dirty使得只有在统计的信息发生变化时才被调用

   （2）需要，因为update_grade函数更改了grade，is_dirty起作用，使computer调用位置

四：在info函数中添加。

   double median() const

   {

        If(grades.empty())

{

   Return -1.0;

}

std::vector<int>temp=grades;

std::sort(temp.begin(),temp.end());

size_t n=temp.size();

if(n%2==1)

{

   return temp[n/2];

}

else

{

   Return (temp[n/2-1]+temp[n/2])/2.0;

}

}

   std::cout<<”中位数统计：\t”<<median()<<std::endl;

五：不能，如果删掉，在多次调用computer时会累计之前的统计结果，造成统计错误

六：（1）对程序功能无影响

   （2）有，当n较大时会导致vector多次扩充，降低运行效率

任务二：

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

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

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

运行结果：

屏幕截图 2025-12-02 194512

问题：

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

二：不会。因为GradeCalc是私有继承，在类外部不会被访问

三：组合方式只暴露了grades成员，封装性强，继承方式通过this访问，封装性弱一点

四：组合方案封装性好，可以避免成绩被轻易修改，更合适

任务三:

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

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

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

运行结果：

屏幕截图 2025-12-02 200156

问题：

一：（1）std::vector<Graph*> graphs;存储多个图形对象的指针，用于统一管理不同图形

（2）class Circle : public Graph   class Triangle : public Graph  class Rectangle : public Graph 

二：（1）Canvas::paint()中的g->draw()将只会调用Graph::draw()，运行结果就为空

（2）派生类对象赋值给基类对象时，派生类特有部分被"切掉"，无法通过基类指针/引用调用派生类的方法

（3）通过基类指针删除派生类对象时，只会调用基类的析构函数，派生类的析构函数不会被调用

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

四：（1）make_graph返回的对象在Canvas析构函数中被释放

（2）利：使用原始指针更简单，可以管理内存生命周期，对指针的控制更精确

弊：使用原始指针时，容易忘记释放内存，导致内存泄漏，可能出现重复释放同一块内存

任务四：

demo4.cpp

#include "ToySystem.hpp"
#include <iostream>
#include <memory>

class Sing : public SpecialAbility {
public:
    void perform() const override {
        std::cout << "唱歌中..." << std::endl;
    }
    
    std::unique_ptr<SpecialAbility> clone() const override {
        return std::unique_ptr<Sing>(new Sing(*this));
    }
};

class Dance : public SpecialAbility {
public:
    void perform() const override {
        std::cout << "跳舞中..." << std::endl;
    }
    
    std::unique_ptr<SpecialAbility> clone() const override {
        return std::unique_ptr<Dance>(new Dance(*this));
    }
};

class StuffedToy : public Toy {
private:
    std::string color;
    
public:
    StuffedToy(const std::string& name, const std::string& color, 
               SpecialAbility* ability = nullptr)
        : Toy(name, ability), color(color) {}
    
    void show() const override {
        std::cout << name << " (" << color << ")" << std::endl;
    }
    
    std::unique_ptr<Toy> clone() const override {
        return std::unique_ptr<StuffedToy>(new StuffedToy(*this));
    }
};

class RobotToy : public Toy {
private:
    int power;
    
public:
    RobotToy(const std::string& name, int power, SpecialAbility* ability = nullptr)
        : Toy(name, ability), power(power) {}
    
    void show() const override {
        std::cout << name << " [能量:" << power << "]" << std::endl;
    }
    
    std::unique_ptr<Toy> clone() const override {
        return std::unique_ptr<RobotToy>(new RobotToy(*this));
    }
};

int main() {
    ToyFactory factory;
    
    std::cout << "=== 玩具系统演示 (C++11) ===" << std::endl;
    
    std::cout << "\n1. 创建玩具..." << std::endl;
    factory.addToy<StuffedToy>("小熊", "棕色", new Sing());
    factory.addToy<RobotToy>("机器人", 100, new Dance());
    factory.addToy<StuffedToy>("兔子", "白色");
    
    factory.displayAll();
    
    factory.testAll();
    
    std::cout << "\n2. 动态修改功能..." << std::endl;
    
    factory.addToy<RobotToy>("变形金刚", 200);
    
    factory.testAll();
    
    std::cout << "\n3. 克隆演示..." << std::endl;
    StuffedToy original("原型熊", "红色", new Sing());
    std::cout << "原始玩具: ";
    original.show();
    
    auto cloned = original.clone();
    std::cout << "克隆玩具: ";
    cloned->show();
    
    std::cout << "\n=== 演示完成 ===" << std::endl;
    
    return 0;
}

ToySystem.cpp

#include "ToySystem.hpp"
#include <utility>

Toy::Toy(const std::string& name, SpecialAbility* ability) 
    : name(name) {
    if (ability) {
        this->ability.reset(ability->clone().release());
    }
}

Toy::Toy(const Toy& other) : name(other.name) {
    if (other.ability) {
        ability.reset(other.ability->clone().release());
    }
}

void Toy::use() const {
    if (ability) {
        ability->perform();
    } else {
        std::cout << name << " 没有特殊功能" << std::endl;
    }
}

void Toy::setAbility(SpecialAbility* newAbility) {
    if (newAbility) {
        ability.reset(newAbility->clone().release());
    } else {
        ability.reset();
    }
}

void ToyFactory::displayAll() const {
    std::cout << "\n=== 所有玩具 ===" << std::endl;
    for (size_t i = 0; i < toys.size(); ++i) {
        std::cout << i + 1 << ". ";
        toys[i]->show();
    }
    std::cout << "总计: " << toys.size() << " 个玩具" << std::endl;
}

void ToyFactory::testAll() const {
    std::cout << "\n=== 功能测试 ===" << std::endl;
    for (const auto& toy : toys) {
        std::cout << toy->getName() << ": ";
        toy->use();
    }
}

ToySystem.hpp

#ifndef TOYSYSTEM_HPP
#define TOYSYSTEM_HPP

#include <iostream>
#include <string>
#include <vector>
#include <memory>

class SpecialAbility {
public:
    virtual ~SpecialAbility() {}
    virtual void perform() const = 0;
    virtual std::unique_ptr<SpecialAbility> clone() const = 0;
};

class Toy {
protected:
    std::string name;
    std::unique_ptr<SpecialAbility> ability;

public:
    Toy(const std::string& name, SpecialAbility* ability = nullptr);
    Toy(const Toy& other);
    virtual ~Toy() {}
    
    virtual void show() const = 0;
    virtual void use() const;
    
    void setAbility(SpecialAbility* newAbility);
    const std::string& getName() const { return name; }
    bool hasAbility() const { return ability != nullptr; }
    
    virtual std::unique_ptr<Toy> clone() const = 0;
};

class ToyFactory {
private:
    std::vector<std::unique_ptr<Toy>> toys;

public:
    template<typename T, typename... Args>
    void addToy(Args&&... args) {
        toys.emplace_back(new T(std::forward<Args>(args)...));
    }
    
    void displayAll() const;
    void testAll() const;
    size_t size() const { return toys.size(); }
    void clear() { toys.clear(); }
};

#endif

运行结果：

屏幕截图 2025-12-02 202622

 

posted @ 2025-12-02 20:28  yueTO  阅读(0)  评论(0)    收藏  举报