#include 
#include 
#include 

// 前向声明
class Visitor;

// 抽象元素基类
class Element {
public:
    virtual ~Element() = default;
    virtual void accept(Visitor& visitor) = 0;
};

// 具体元素：数字
class Number : public Element {
    double value_;
public:
    explicit Number(double v) : value_(v) {}
    double value() const { return value_; }
    void accept(Visitor& visitor) override;
};

// 具体元素：文本
class Text : public Element {
    std::string content_;
public:
    explicit Text(const std::string& s) : content_(s) {}
    const std::string& content() const { return content_; }
    void accept(Visitor& visitor) override;
};

// 抽象访问者
class Visitor {
public:
    virtual ~Visitor() = default;
    virtual void visit(Number& n) = 0;
    virtual void visit(Text& t) = 0;
};

// 具体访问者：打印器
class Printer : public Visitor {
public:
    void visit(Number& n) override {
        std::cout << "Number: " << n.value() << "\n";
    }
    void visit(Text& t) override {
        std::cout << "Text: \"" << t.content() << "\"\n";
    }
};

// 实现 Element::accept（关键：实现双分派）
void Number::accept(Visitor& visitor) {
    visitor.visit(*this); // 运行时确定 this 类型 → 调用 visit(Number&)
}
void Text::accept(Visitor& visitor) {
    visitor.visit(*this); // 运行时确定 this 类型 → 调用 visit(Text&)
}

// 对象结构（可选封装）
class ObjectStructure {
    std::vector> elements_;
public:
    void add(std::unique_ptr e) {
        elements_.push_back(std::move(e));
    }
    void traverse(Visitor& visitor) {
        for (auto& e : elements_) {
            e->accept(visitor);
        }
    }
};

// 使用示例
int main() {
    ObjectStructure os;
    os.add(std::make_unique(3.14));
    os.add(std::make_unique("Hello Visitor"));
    os.add(std::make_unique(42));

    Printer printer;
    os.traverse(printer);
    // 输出：
    // Number: 3.14
    // Text: "Hello Visitor"
    // Number: 42
}