class Game{
public:
static Game *getgame(){
    if(game == nullptr){
        game = new(Game);
    }
    return game;
}
private:
    static Game *game
}

struct Character{
protected:
    virtual void drow();
    virtual void move();
public:
    void updata(){
        move();
        move();
        move();
        drow();
    }
};
struct Game{
    vector<character *> chars;
    void updata(){
        for(auto && c : chars){
            c->updata();
        }
    }
}

// 视线深拷贝
Ball *ball = new RedBall();
Ball *newball = new BedBall(*dynamic_cast<RedBall *>(ball));

struct Ball{
    virtual thread_ptr(Ball) *close() = 0;//加入thread_ptr 实现内存智能管理
};

struct RedBall :Ball{
    thread_ptr(Ball) *close() override{
        return new RedBall(*this);
    }
    int x ;// 如果有成员变量，也会一并被拷贝到
}

Ball *ball = new RedBall();
Ball *ball_2 = ball->close(); //视线深拷贝,

struct Ball {
    virtual unique_ptr<Ball> clone() = 0;
};

template <class Derived>
struct BallImpl : Ball {  // 自动实现 clone 的辅助工具类
    unique_ptr<Ball> clone() override {
        Derived *that = static_cast<Derived *>(this);
        return make_unique<Derived>(*that);
    }
};

struct RedBall : BallImpl<RedBall> {
    // unique_ptr<Ball> clone() override {       // BallImpl 自动实现的 clone 等价于
    //     return make_unique<RedBall>(*this);  // 调用 RedBall 的拷贝构造函数
    // }
};

struct BlueBall : BallImpl<BlueBall> {
    // unique_ptr<Ball> clone() override {       // BallImpl 自动实现的 clone 等价于
    //     return make_unique<BlueBall>(*this);  // 调用 BlueBall 的拷贝构造函数
    // }
};


Ball *ball = new RedBall();
Ball *ball_2 = ball->close(); //视线深拷贝,

struct connect{
    virtual void updata()
}

struct pet{
    virtual void speak() = 0;
};
struct cat::pet{
    void speak() override{
        print("miao");
    }
};
struct dog::pet{
    void speak() override{
        print("wano");
    }
};
void feed(Pet *pet) {
    puts("喂食");
    pet->speak();
    puts("喂食完毕");
}
int main(){
    pet *cat = new cat();
    pet *dog = new dog();
    freed(cat);
    freed(dog);
}

sturct Reduce(){
    virtual int init() = 0;
    virtual int add(int a,int b) = 0;
};

struct add_our :: Reduce(){
    int init() override{
        return 0;
    }
    int add(int a ,int b) override{
        return a+b;
    }
};
struct chen_our :: Reduce(){
    int init() override{
        return 1;
    }
    int add(int a,int b) override{
        return a*b;
    }
};

int reduce(std::vector<int> v,Reduce & reducer){
    int x =reducer->int();
    for(int i = 0;i<v.size();i++ ){
        x = reducer->add(x, v[i]);
    }
    return x
}

struct Sprite{
    vector<char> texture;
    void draw(glm::vec3 posoition){
        glDrawPixels(posoition, texture);
    }
};
struct Bullet{
    glm::vec3 posoition;
    glm::vec3 velocity;
    shared_ptr<Sprite> sprite;
    
    void draw(){
        sprite->draw(position, velocity);
    }
}

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <functional>

// 线程安全队列模板类
template <typename T>
class SafeQueue {
public:
    SafeQueue() = default;

    // 禁用拷贝构造和赋值操作
    SafeQueue(const SafeQueue&) = delete;
    SafeQueue& operator=(const SafeQueue&) = delete;

    // 入队操作
    void enqueue(T item) {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_queue.push(std::move(item));
        m_cond.notify_one();
    }

    // 出队操作，阻塞等待直到队列非空
    T dequeue() {
        std::unique_lock<std::mutex> lock(m_mutex);
        m_cond.wait(lock, [this]{ return !m_queue.empty(); });
        T item = std::move(m_queue.front());
        m_queue.pop();
        return item;
    }

    // 尝试出队，不阻塞
    bool try_dequeue(T& item) {
        std::lock_guard<std::mutex> lock(m_mutex);
        if(m_queue.empty()) return false;
        item = std::move(m_queue.front());
        m_queue.pop();
        return true;
    }

    bool empty() const {
        std::lock_guard<std::mutex> lock(m_mutex);
        return m_queue.empty();
    }

private:
    mutable std::mutex m_mutex; // 互斥
    std::queue<T> m_queue; // 队列
    std::condition_variable m_cond;// 通知
};

// 测试队列和线程
int main() {
    SafeQueue<std::function<void()>> tasks;

    // 生产者线程
    std::thread producer([&tasks]() {
        for(int i = 1; i <= 5; i++) {
            tasks.enqueue([i]() { std::cout << "Task " << i << " executed"; });
        }
    });

    // 消费者线程
    std::thread consumer([&tasks]() {
        for(int i = 1; i <= 5; i++) {
            auto task = tasks.dequeue();
            task();
        }
    });

    producer.join();
    consumer.join();

    return 0;
}