实验4

实验任务一：

#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;
    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.hpp

#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 = 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 (int i = 0; i < rates.size(); ++i)
        rates[i] = counts[i] * 1.0 / grades.size();

    is_dirty = false;  // 更新脏标记
}

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

void test(){
    GradeCalc cl("OOP");

    std::cout << "录入成绩:\n";
    cl.input(5);

    std::cout << "输出成绩:\n";
    cl.output();

    std::cout << "排序后成绩:\n";
    cl.sort();cl.output();

    std::cout << "*************成绩统计信息*************\n";
    cl.info();
}

int main(){
    test();
}

demo1.cpp

运行结果为：

 问题一：    std::string course_name; // 组合的string对象，用于存储课程名称

                  std::vector<int> grades; // 组合的vector对象，用于动态存储所有成绩   

                  std::array<int,5> counts; // 组合的array对象，用于固定存储五个分数段的人数

                std::array<double,5> rates; // 组合的array对象，用于固定存储五个分数段的比例

问题二：

不合法，push_back 是 std::vector 类的成员函数，但在 GradeCalc 类的设计中没有将此函数公开暴露。GradeCalc 类通过其封装的方法（如 input() 和 compute()）来管理内部的 grades 向量，用户无法直接访问或修

改底层的 std::vector 对象。

问题三：

（1）连续三次打印统计信息时，compute() 仅会在第一次被调用，因为第一次调用后 is_dirty 被设为 false，后续调用直接使用缓存的统计结果，从而避免了重复计算，提升了性能。

（2）如果新增 update_grade(index, new_grade) 方法，无需改变 compute() 的调用位置，只需在修改成绩后将 is_dirty 设为 true，这样下次调用 info() 时便会自动触发重新计算，既保持了架构的惰性计算模式，又

确保了数据更新后的统计准确性。

问题四：要增加“中位数”统计且不新增数据成员，可以在 info() 函数中临时计算：首先复制当前成绩向量，排序后根据元素个数的奇偶性计算中位数值（偶数个时取中间两个数的平均值，奇数个时直接取中间值），最后

输出结果。这种方法避免了永久存储中位数，只在需要时动态计算，符合不新增数据成员的要求。

问题五：compute() 中的清零语句不能去掉，因为每次计算统计信息时必须从零开始重新统计。如果去掉这两行，在多次调用 compute() 且成绩数据发生变更的场景下（例如删除或修改成绩后），旧的统计结果会与新的统

计结果累加，导致各分数段人数和比例计算错误，无法反映真实的成绩分布情况。

问题六：去掉 grades.reserve(n) 对程序功能没有影响，成绩录入和统计功能仍能正常工作；但对性能有影响，具体表现为：当一次性录入大量成绩时，vector 可能需要进行多次内存重新分配和数据复制操作，增加运行时

间和资源消耗，而使用 reserve() 可以一次性分配足够内存，避免这些开销。

实验任务二：

 

#pragma once

#include <vector>
#include <array>
#include <string>

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::vector<int> grades;
    std::array<int,5> counts;//保存各分数段人数
    std::array<double,5> rates;//保存各分数段人数占比
    bool is_dirty;//脏标记，记录是否成绩信息有变更
}; 

GradeCalc.hpp

 

#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";   //cerr（标准错误输出流）
        //与cout是两个独立的流，可通过系统分离（如将普通输出写入文件，错误输出仍显示在屏幕）
        //cerr无缓冲
        return;
    }

    this->reserve(n);//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());//sort默认升序
    else
        std::sort(this->begin(),this->end(),std::greater<int>());//greater专门用来表示“大于”关系//()表示创建一个实例
}

int GradeCalc::min() const{
    if(this->empty())
        return -1;
    
        //min_element函数定义在<algorithm>头文件中，默认<比较
    auto it = std::min_element(this->begin(),this->end());
    return *it;//迭代器it是指针类型
}

int GradeCalc::max() const{
    if(this->empty())
        return -1;

    auto it = std::max_element(this->begin(),this->end());
    return *it;
}

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" << median() << std::endl;
    //std::fixed来自<iomanip>,指定浮点数以固定小数点格式进行输出，通常与std::setprecision()搭配使用
    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 = 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.0);

    //统计各分数段人数
    for(auto grade:*this){
        if(grade < 60)
            ++counts[0];
        else if (grade < 70)
            ++counts[1];
        else if (grade < 80)
            ++counts[2];
        else if (grade < 90)
            ++counts[3];
        else
            ++counts[4];
    }

    //统计各分数段比例
    for(int i = 0;i < rates.size();i++)
        rates[i] = counts[i] * 1.0/this->size();

    is_dirty = false;
}

GradeCalc.cpp

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

void test(){
    GradeCalc cl("OOP");

    std::cout << "录入成绩:\n";
    cl.input(5);

    std::cout << "输出成绩:\n";
    cl.output();

    std::cout << "*************排序前成绩统计信息*************\n";
    cl.info();

    std::cout << "排序后成绩:\n";
    cl.sort();cl.output();

    std::cout << "*************成绩统计信息*************\n";
    cl.info();
}

int main(){
    test();
}

demo2.cpp

运行结果为：

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

问题二：无法，因为私有继承使基类 std::vector<int> 的所有公有接口在 GradeCalc 中都变成了私有成员，外部代码无法直接访问。

问题三：在组合方式下，`for(auto grade: grades)` 通过直接访问私有成员 `grades` 来遍历数据，这体现了严格的封装性，成绩数据作为类的内部对象完全由 `GradeCalc` 控制，外部无法直接接触；而在继承方式下，`for(int grade: *this)` 通过将 `GradeCalc` 对象自身（`*this`）作为基类 `std::vector<int>` 来遍历数据，这利用了继承的“是一个”关系，虽然内部实现可以直接使用基类的丰富接口（如迭代器），但两种方式的封装差异显著：组合方式对外完全隐藏了数据容器，仅暴露自定义的有限接口，而继承方式（尤其是私有继承）虽然在外部同样屏蔽了基类接口，但在类内部获得了更直接的数据访问能力，减少了中间层，这反映了组合强调“拥有”的独立控制和继承强调“扩展”的内在复用之间的根本不同。

问题四：在成绩计算这一具体场景中，组合方案明显优于继承方案，因为成绩管理类本质上是一个具有明确业务逻辑的领域对象，它“拥有”一个成绩集合（组合关系）而非“是一个”成绩集合（继承关系），组合方式通过将 `std::vector<int>` 作为私有成员，既能够严格封装底层数据，仅暴露必要的业务接口（如 `input`、`info`），避免用户误用无关的容器操作，又保持了未来更换内部数据结构的灵活性，同时更准确地反映了成绩计算器的现实语义——它是一个管理工具而非数据容器本身，这确保了代码的清晰性、安全性和可维护性。

实验任务三：

#pragma once

#include <string>
#include <vector>

enum class GraphType {circle,triangle,rectangle};//枚举类enum class属于枚举类型

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

//工具函数
GraphType str_to_GraphType(const std::string& s);//字符串转枚举类型
Graph* make_graph(const std::string& type);//创建图形，返回堆对象指针

Graph.hpp

#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();//调用每一个graphs中具体图形的draw函数
}

Canvas::~Canvas(){
    for(Graph* g :graphs)
        delete g;//释放内存
}

//工具函数实现
//字符串 -> 枚举转换//把用户的字符串指令转成程序内部能识别的枚举标记
GraphType str_to_GraphType(const std::string& s){
    std::string t = s;
    //批量处理容器元素//将s中所有字符转为小写，并把结果存到字符串t中，解决“字符串大小写不匹配”的问题
    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.cpp

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

void test() {
    Canvas canvas;

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

int main() {
    test();
}

demo3.cpp

运行结果为：

问题一：（1）体现"组合"关系的成员声明代码行是 std::vector<Graph*> graphs;，被组合的 std::vector<Graph*> 对象用于动态存储和管理指向图形对象的指针，作为画布容器统一持有所有图形对象。

            （2）体现"继承"关系的类声明代码行包括：class Circle : public Graph;、class Triangle : public Graph; 和 class Rectangle : public Graph;，这些行声明了具体图形类公有继承自抽象基类 Graph，形成了"是一个"的继承关系。

问题二：（1）如果 Graph::draw() 未声明为虚函数，Canvas::paint() 中的 g->draw() 将调用基类 Graph 的 draw() 而非具体子类的实现，导致无论实际对象类型是什么都输出相同的基类行为，无法实现多态。
            （2）如果将 std::vector<Graph*> 改为 std::vector<Graph>，会发生对象切片（object slicing）问题，容器中存储的是基类 Graph 对象而非指针，派生类的特有属性和行为会丢失，且无法通过基类指针调用派生类的虚函数。

            （3）如果 ~Graph() 未声明为虚函数，通过基类指针删除派生类对象时只会调用基类析构函数，派生类部分不会被正确清理，导致派生类特有的资源泄漏，这是基类析构函数非虚时使用多态的典型问题。

问题三：

若要新增星形 Star，需要在以下文件做改动：Graph.hpp：在 enum class GraphType 中添加 star 枚举值；添加 class Star : public Graph 类声明

                                                             Graph.cpp：实现 Star::draw() 函数；在 str_to_GraphType() 中添加字符串 "star" 到枚举的转换；在 make_graph() 的 switch 语句中添加 GraphType::star 对应的 new Star 分支

                                                              测试代码：可添加对 "star" 的测试调用

问题四：（1）make_graph 返回的对象（堆内存）在 Canvas 析构函数中被释放，当 Canvas 对象销毁时，它会遍历 graphs 容器并对每个指针调用 delete，从而释放每个图形对象的内存。

            （2）使用原始指针管理内存的利在于简单直接、无额外开销；弊在于需要手动管理内存释放，易导致内存泄漏（如忘记 delete）、悬垂指针（如重复 delete）或所有权不清晰，在现代 C++ 中更推荐使用智能指针                         （如 std::unique_ptr）来自动管理资源生命周期。

实验任务四：

问题描述：设计一个电子毛绒玩具管理系统，能够管理不同类型的毛绒玩具（如会说话的熊、发光的小狗、会唱歌的兔子等），每种玩具具有不同的"特异功能"。系统需要提供统一的接口来展示所有玩具的信息和调用它们的特异功能。

对象关系设计：继承关系：所有具体玩具类继承自抽象基类 Toy

                     组合关系：ToyFactory 包含玩具对象的集合

                     多态机制：通过虚函数实现统一的特异功能接口

代码：

#pragma once

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

// 玩具类型枚举
enum class ToyType {
    TALKING,    // 会说话的玩具
    GLOWING,    // 发光的玩具
    SINGING,    // 会唱歌的玩具
    DANCING,    // 会跳舞的玩具
    SMART       // 智能互动玩具
};

// 抽象基类：毛绒玩具
class Toy {
public:
    Toy(const std::string& name, ToyType type, float price, int batteryLife);
    virtual ~Toy() = default;
    
    // 基本信息获取
    std::string getName() const;
    ToyType getType() const;
    float getPrice() const;
    int getBatteryLife() const;
    
    // 状态管理
    bool isOn() const;
    void turnOn();
    void turnOff();
    void recharge(int minutes);
    
    // 虚函数 - 特异功能（多态接口）
    virtual void specialFunction() = 0;
    virtual void displayInfo() const;
    virtual std::string getDescription() const;
    
protected:
    std::string name;
    ToyType type;
    float price;
    int batteryLife;        // 电池续航时间（分钟）
    bool isPoweredOn;
    int remainingBattery;   // 剩余电量（百分比）
};

// 具体玩具类：会说话的熊
class TalkingBear : public Toy {
public:
    TalkingBear(const std::string& name, float price, const std::string& phrase);
    void specialFunction() override;
    std::string getDescription() const override;
    
private:
    std::string catchphrase;
    std::vector<std::string> stories;
    void tellStory();
};

// 具体玩具类：发光的小狗
class GlowingDog : public Toy {
public:
    GlowingDog(const std::string& name, float price, const std::string& color);
    void specialFunction() override;
    void displayInfo() const override;
    
private:
    std::string glowColor;
    int brightnessLevel;
    void changeColor(const std::string& newColor);
    void adjustBrightness(int level);
};

// 具体玩具类：会唱歌的兔子
class SingingRabbit : public Toy {
public:
    SingingRabbit(const std::string& name, float price, const std::string& song);
    void specialFunction() override;
    void addSong(const std::string& song);
    
private:
    std::vector<std::string> songs;
    int currentSongIndex;
    void playNextSong();
};

// 具体玩具类：跳舞的熊猫
class DancingPanda : public Toy {
public:
    DancingPanda(const std::string& name, float price, const std::string& danceStyle);
    void specialFunction() override;
    void displayInfo() const override;
    
private:
    std::string danceStyle;
    int danceSpeed;
    void performDanceMove(const std::string& move);
};

// 具体玩具类：智能猫头鹰
class SmartOwl : public Toy {
public:
    SmartOwl(const std::string& name, float price, int iqLevel);
    void specialFunction() override;
    std::string getDescription() const override;
    void askQuestion(const std::string& question);
    
private:
    int iqLevel;
    std::vector<std::string> knowledgeBase;
    std::string generateAnswer(const std::string& question);
};

#pragma once

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

class ToyFactory {
public:
    ToyFactory();
    
    // 工厂管理接口
    void addToy(std::unique_ptr<Toy> toy);
    void createSampleToys();  // 创建示例玩具
    void displayAllToys() const;
    void demonstrateAllFunctions() const;
    void findToysByType(ToyType type) const;
    void rechargeAllToys();
    
    // 统计信息
    int getTotalToys() const;
    float getTotalValue() const;
    void displayStatistics() const;
    
private:
    std::vector<std::unique_ptr<Toy>> toys;
    
    // 辅助函数
    std::string typeToString(ToyType type) const;
    void displaySeparator() const;
};

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

// Toy基类实现
Toy::Toy(const std::string& name, ToyType type, float price, int batteryLife)
    : name(name), type(type), price(price), batteryLife(batteryLife),
      isPoweredOn(false), remainingBattery(100) {}

std::string Toy::getName() const { return name; }
ToyType Toy::getType() const { return type; }
float Toy::getPrice() const { return price; }
int Toy::getBatteryLife() const { return batteryLife; }

bool Toy::isOn() const { return isPoweredOn; }

void Toy::turnOn() {
    if (remainingBattery > 0) {
        isPoweredOn = true;
        std::cout << name << " 已启动！" << std::endl;
    } else {
        std::cout << name << " 电量不足，请先充电！" << std::endl;
    }
}

void Toy::turnOff() {
    isPoweredOn = false;
    std::cout << name << " 已关闭。" << std::endl;
}

void Toy::recharge(int minutes) {
    int chargeAmount = minutes / 10;  // 每10分钟充10%
    remainingBattery = std::min(100, remainingBattery + chargeAmount);
    std::cout << name << " 充电完成，当前电量: " << remainingBattery << "%" << std::endl;
}

void Toy::displayInfo() const {
    std::cout << "\n=== 玩具信息 ===" << std::endl;
    std::cout << "名称: " << name << std::endl;
    std::cout << "价格: ¥" << std::fixed << std::setprecision(2) << price << std::endl;
    std::cout << "电池续航: " << batteryLife << " 分钟" << std::endl;
    std::cout << "当前状态: " << (isPoweredOn ? "开启" : "关闭") << std::endl;
    std::cout << "剩余电量: " << remainingBattery << "%" << std::endl;
}

std::string Toy::getDescription() const {
    return "一个普通的毛绒玩具";
}

// TalkingBear实现
TalkingBear::TalkingBear(const std::string& name, float price, const std::string& phrase)
    : Toy(name, ToyType::TALKING, price, 120), catchphrase(phrase) {
    stories = {"三只小熊的故事", "森林冒险记", "蜂蜜大冒险"};
}

void TalkingBear::specialFunction() {
    if (!isOn()) {
        std::cout << "请先打开 " << name << "！" << std::endl;
        return;
    }
    
    std::cout << "\n🐻 " << name << " 说: \"" << catchphrase << "\"" << std::endl;
    tellStory();
}

void TalkingBear::tellStory() {
    std::cout << "📖 开始讲故事..." << std::endl;
    for (const auto& story : stories) {
        std::cout << "  正在讲述: " << story << std::endl;
    }
    remainingBattery -= 5;
}

std::string TalkingBear::getDescription() const {
    return "一只可爱的会说话的泰迪熊，可以说口号和讲故事";
}

// GlowingDog实现
GlowingDog::GlowingDog(const std::string& name, float price, const std::string& color)
    : Toy(name, ToyType::GLOWING, price, 180), glowColor(color), brightnessLevel(5) {}

void GlowingDog::specialFunction() {
    if (!isOn()) {
        std::cout << "请先打开 " << name << "！" << std::endl;
        return;
    }
    
    std::cout << "\n✨ " << name << " 开始发光！" << std::endl;
    std::cout << "发光颜色: " << glowColor << std::endl;
    std::cout << "亮度级别: " << brightnessLevel << "/10" << std::endl;
    
    // 模拟颜色变化
    std::vector<std::string> colors = {"红色", "蓝色", "绿色", "彩虹色"};
    for (const auto& color : colors) {
        changeColor(color);
        adjustBrightness(rand() % 10 + 1);
    }
    
    remainingBattery -= 8;
}

void GlowingDog::displayInfo() const {
    Toy::displayInfo();
    std::cout << "发光颜色: " << glowColor << std::endl;
    std::cout << "当前亮度: " << brightnessLevel << "/10" << std::endl;
}

void GlowingDog::changeColor(const std::string& newColor) {
    glowColor = newColor;
    std::cout << "  颜色变为: " << glowColor << std::endl;
}

void GlowingDog::adjustBrightness(int level) {
    brightnessLevel = level;
    std::cout << "  亮度调整为: " << brightnessLevel << std::endl;
}

// SingingRabbit实现
SingingRabbit::SingingRabbit(const std::string& name, float price, const std::string& song)
    : Toy(name, ToyType::SINGING, price, 150), currentSongIndex(0) {
    songs.push_back(song);
    songs.push_back("小星星");
    songs.push_back("生日快乐");
    songs.push_back("两只老虎");
}

void SingingRabbit::specialFunction() {
    if (!isOn()) {
        std::cout << "请先打开 " << name << "！" << std::endl;
        return;
    }
    
    std::cout << "\n🎵 " << name << " 开始唱歌！" << std::endl;
    for (int i = 0; i < 3; i++) {
        playNextSong();
    }
    remainingBattery -= 6;
}

void SingingRabbit::addSong(const std::string& song) {
    songs.push_back(song);
    std::cout << "新歌曲 '" << song << "' 已添加！" << std::endl;
}

void SingingRabbit::playNextSong() {
    std::cout << "  正在演唱: 《" << songs[currentSongIndex] << "》" << std::endl;
    currentSongIndex = (currentSongIndex + 1) % songs.size();
}

// DancingPanda实现
DancingPanda::DancingPanda(const std::string& name, float price, const std::string& danceStyle)
    : Toy(name, ToyType::DANCING, price, 200), danceStyle(danceStyle), danceSpeed(5) {}

void DancingPanda::specialFunction() {
    if (!isOn()) {
        std::cout << "请先打开 " << name << "！" << std::endl;
        return;
    }
    
    std::cout << "\n💃 " << name << " 开始跳舞！" << std::endl;
    std::cout << "舞蹈风格: " << danceStyle << std::endl;
    std::cout << "舞蹈速度: " << danceSpeed << "/10" << std::endl;
    
    std::vector<std::string> moves = {"旋转", "跳跃", "摇摆", "翻滚"};
    for (const auto& move : moves) {
        performDanceMove(move);
    }
    
    remainingBattery -= 10;
}

void DancingPanda::displayInfo() const {
    Toy::displayInfo();
    std::cout << "舞蹈风格: " << danceStyle << std::endl;
    std::cout << "舞蹈速度: " << danceSpeed << "/10" << std::endl;
}

void DancingPanda::performDanceMove(const std::string& move) {
    std::cout << "  执行动作: " << move << std::endl;
}

// SmartOwl实现
SmartOwl::SmartOwl(const std::string& name, float price, int iqLevel)
    : Toy(name, ToyType::SMART, price, 300), iqLevel(iqLevel) {
    knowledgeBase = {
        "太阳从东边升起",
        "水在100°C沸腾",
        "地球是圆的",
        "猫头鹰是夜行动物"
    };
}

void SmartOwl::specialFunction() {
    if (!isOn()) {
        std::cout << "请先打开 " << name << "！" << std::endl;
        return;
    }
    
    std::cout << "\n🦉 " << name << " 启动智能模式！" << std::endl;
    std::cout << "智商级别: " << iqLevel << "/10" << std::endl;
    
    std::vector<std::string> questions = {
        "太阳从哪里升起？",
        "水的沸点是多少？",
        "地球是什么形状的？"
    };
    
    for (const auto& question : questions) {
        askQuestion(question);
    }
    
    remainingBattery -= 12;
}

std::string SmartOwl::getDescription() const {
    return "一只聪明的猫头鹰玩具，可以回答问题，智商等级: " + std::to_string(iqLevel);
}

void SmartOwl::askQuestion(const std::string& question) {
    std::cout << "问: " << question << std::endl;
    std::cout << "答: " << generateAnswer(question) << std::endl;
}

std::string SmartOwl::generateAnswer(const std::string& question) {
    for (const auto& fact : knowledgeBase) {
        if (question.find(fact.substr(0, 3)) != std::string::npos) {
            return fact;
        }
    }
    return "我不知道答案，但我会继续学习！";
}

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

ToyFactory::ToyFactory() {}

void ToyFactory::addToy(std::unique_ptr<Toy> toy) {
    toys.push_back(std::move(toy));
    std::cout << "玩具 '" << toys.back()->getName() << "' 已添加到工厂！" << std::endl;
}

void ToyFactory::createSampleToys() {
    // 清空现有玩具
    toys.clear();
    
    // 创建示例玩具
    addToy(std::make_unique<TalkingBear>("泰迪", 199.99, "我是泰迪熊，我们一起玩吧！"));
    addToy(std::make_unique<GlowingDog>("闪闪", 159.99, "蓝色"));
    addToy(std::make_unique<SingingRabbit>("乐乐", 179.99, "小兔子乖乖"));
    addToy(std::make_unique<DancingPanda>("舞王", 249.99, "街舞"));
    addToy(std::make_unique<SmartOwl>("博士", 299.99, 8));
    addToy(std::make_unique<TalkingBear>("波波", 189.99, "你好，我是波波熊！"));
    
    std::cout << "\n✅ 已创建 " << toys.size() << " 个示例玩具！" << std::endl;
}

void ToyFactory::displayAllToys() const {
    if (toys.empty()) {
        std::cout << "\n工厂里还没有玩具！" << std::endl;
        return;
    }
    
    displaySeparator();
    std::cout << "🎪 玩具工厂 - 所有玩具列表 (" << toys.size() << "个)" << std::endl;
    displaySeparator();
    
    for (size_t i = 0; i < toys.size(); ++i) {
        std::cout << "\n[" << i + 1 << "] ";
        toys[i]->displayInfo();
        std::cout << "类型: " << typeToString(toys[i]->getType()) << std::endl;
        std::cout << "描述: " << toys[i]->getDescription() << std::endl;
    }
    displaySeparator();
}

void ToyFactory::demonstrateAllFunctions() const {
    if (toys.empty()) {
        std::cout << "\n工厂里还没有玩具！" << std::endl;
        return;
    }
    
    displaySeparator();
    std::cout << "🎭 玩具特异功能演示" << std::endl;
    displaySeparator();
    
    for (const auto& toy : toys) {
        // 先打开玩具
        toy->turnOn();
        
        // 演示特异功能
        toy->specialFunction();
        
        // 关闭玩具
        toy->turnOff();
        
        std::cout << std::endl;
    }
    displaySeparator();
}

void ToyFactory::findToysByType(ToyType type) const {
    std::cout << "\n🔍 查找类型为 " << typeToString(type) << " 的玩具：" << std::endl;
    
    bool found = false;
    for (const auto& toy : toys) {
        if (toy->getType() == type) {
            if (!found) {
                found = true;
                std::cout << "找到以下玩具：" << std::endl;
            }
            std::cout << "  - " << toy->getName() 
                      << " (¥" << std::fixed << std::setprecision(2) << toy->getPrice() << ")" << std::endl;
        }
    }
    
    if (!found) {
        std::cout << "未找到该类型的玩具。" << std::endl;
    }
}

void ToyFactory::rechargeAllToys() {
    std::cout << "\n🔋 为所有玩具充电..." << std::endl;
    for (const auto& toy : toys) {
        toy->recharge(30);  // 充电30分钟
    }
    std::cout << "所有玩具充电完成！" << std::endl;
}

int ToyFactory::getTotalToys() const {
    return static_cast<int>(toys.size());
}

float ToyFactory::getTotalValue() const {
    float total = 0.0f;
    for (const auto& toy : toys) {
        total += toy->getPrice();
    }
    return total;
}

void ToyFactory::displayStatistics() const {
    displaySeparator();
    std::cout << "📊 工厂统计信息" << std::endl;
    displaySeparator();
    
    std::cout << "玩具总数: " << getTotalToys() << " 个" << std::endl;
    std::cout << "总价值: ¥" << std::fixed << std::setprecision(2) << getTotalValue() << std::endl;
    
    // 按类型统计
    std::vector<int> typeCount(5, 0);  // 对应5种类型
    for (const auto& toy : toys) {
        typeCount[static_cast<int>(toy->getType())]++;
    }
    
    std::cout << "\n按类型分布：" << std::endl;
    for (int i = 0; i < 5; i++) {
        if (typeCount[i] > 0) {
            std::cout << "  " << typeToString(static_cast<ToyType>(i)) 
                      << ": " << typeCount[i] << " 个" << std::endl;
        }
    }
    displaySeparator();
}

std::string ToyFactory::typeToString(ToyType type) const {
    switch (type) {
        case ToyType::TALKING: return "会说话的玩具";
        case ToyType::GLOWING: return "发光的玩具";
        case ToyType::SINGING: return "会唱歌的玩具";
        case ToyType::DANCING: return "会跳舞的玩具";
        case ToyType::SMART: return "智能玩具";
        default: return "未知类型";
    }
}

void ToyFactory::displaySeparator() const {
    std::cout << std::string(40, '=') << std::endl;
}

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

void displayMenu() {
    std::cout << "\n🎮 毛绒玩具管理系统 🎮" << std::endl;
    std::cout << "================================" << std::endl;
    std::cout << "1. 创建示例玩具" << std::endl;
    std::cout << "2. 显示所有玩具信息" << std::endl;
    std::cout << "3. 演示所有玩具特异功能" << std::endl;
    std::cout << "4. 按类型查找玩具" << std::endl;
    std::cout << "5. 为所有玩具充电" << std::endl;
    std::cout << "6. 显示统计信息" << std::endl;
    std::cout << "7. 添加自定义玩具" << std::endl;
    std::cout << "8. 测试单个玩具功能" << std::endl;
    std::cout << "0. 退出程序" << std::endl;
    std::cout << "================================" << std::endl;
    std::cout << "请选择操作: ";
}

void addCustomToy(ToyFactory& factory) {
    std::cout << "\n➕ 添加自定义玩具" << std::endl;
    std::cout << "选择玩具类型：" << std::endl;
    std::cout << "1. 会说话的熊" << std::endl;
    std::cout << "2. 发光的小狗" << std::endl;
    std::cout << "3. 会唱歌的兔子" << std::endl;
    std::cout << "4. 跳舞的熊猫" << std::endl;
    std::cout << "5. 智能猫头鹰" << std::endl;
    
    int choice;
    std::cin >> choice;
    
    std::string name;
    float price;
    
    std::cout << "输入玩具名称: ";
    std::cin >> name;
    std::cout << "输入玩具价格: ";
    std::cin >> price;
    
    switch (choice) {
        case 1: {
            std::string phrase;
            std::cout << "输入口号: ";
            std::cin.ignore();
            std::getline(std::cin, phrase);
            factory.addToy(std::make_unique<TalkingBear>(name, price, phrase));
            break;
        }
        case 2: {
            std::string color;
            std::cout << "输入发光颜色: ";
            std::cin >> color;
            factory.addToy(std::make_unique<GlowingDog>(name, price, color));
            break;
        }
        case 3: {
            std::string song;
            std::cout << "输入默认歌曲: ";
            std::cin.ignore();
            std::getline(std::cin, song);
            factory.addToy(std::make_unique<SingingRabbit>(name, price, song));
            break;
        }
        case 4: {
            std::string danceStyle;
            std::cout << "输入舞蹈风格: ";
            std::cin.ignore();
            std::getline(std::cin, danceStyle);
            factory.addToy(std::make_unique<DancingPanda>(name, price, danceStyle));
            break;
        }
        case 5: {
            int iqLevel;
            std::cout << "输入智商等级 (1-10): ";
            std::cin >> iqLevel;
            factory.addToy(std::make_unique<SmartOwl>(name, price, iqLevel));
            break;
        }
        default:
            std::cout << "无效选择！" << std::endl;
    }
}

void testSingleToy() {
    std::cout << "\n🔧 测试单个玩具功能" << std::endl;
    
    // 测试会说话的熊
    TalkingBear bear("测试熊", 99.99, "测试口号");
    bear.displayInfo();
    bear.turnOn();
    bear.specialFunction();
    bear.turnOff();
    
    std::cout << "\n";
    
    // 测试智能猫头鹰
    SmartOwl owl("测试猫头鹰", 199.99, 9);
    owl.displayInfo();
    owl.turnOn();
    owl.specialFunction();
    owl.turnOff();
}

int main() {
    ToyFactory factory;
    int choice;
    
    do {
        displayMenu();
        std::cin >> choice;
        
        switch (choice) {
            case 1:
                factory.createSampleToys();
                break;
            case 2:
                factory.displayAllToys();
                break;
            case 3:
                factory.demonstrateAllFunctions();
                break;
            case 4: {
                std::cout << "\n选择要查找的类型：" << std::endl;
                std::cout << "1. 会说话的玩具" << std::endl;
                std::cout << "2. 发光的玩具" << std::endl;
                std::cout << "3. 会唱歌的玩具" << std::endl;
                std::cout << "4. 会跳舞的玩具" << std::endl;
                std::cout << "5. 智能玩具" << std::endl;
                
                int typeChoice;
                std::cin >> typeChoice;
                
                if (typeChoice >= 1 && typeChoice <= 5) {
                    factory.findToysByType(static_cast<ToyType>(typeChoice - 1));
                } else {
                    std::cout << "无效选择！" << std::endl;
                }
                break;
            }
            case 5:
                factory.rechargeAllToys();
                break;
            case 6:
                factory.displayStatistics();
                break;
            case 7:
                addCustomToy(factory);
                break;
            case 8:
                testSingleToy();
                break;
            case 0:
                std::cout << "\n感谢使用毛绒玩具管理系统！再见！👋" << std::endl;
                break;
            default:
                std::cout << "无效选择，请重新输入！" << std::endl;
        }
        
        if (choice != 0) {
            std::cout << "\n按回车键继续...";
            std::cin.ignore();
            std::cin.get();
        }
        
    } while (choice != 0);
    
    return 0;
}