C++迭代器模式怎样支持多种遍历 深度优先与广度优先实现

class Iterator {
public:
    virtual bool hasNext() = 0;
    virtual int next() = 0;
};

class DFSIterator : public Iterator {
private:
    std::stack<Node*> stack_;
public:
    DFSIterator(Node* root) {
        if (root) stack_.push(root);
    }

    bool hasNext() override {
        return !stack_.empty();
    }

    int next() override {
        Node* node = stack_.top();
        stack_.pop();
        // 假设是二叉树，先压右后压左，保证左子树先访问
        if (node->right) stack_.push(node->right);
        if (node->left) stack_.push(node->left);
        return node->value;
    }
};

class BFSIterator : public Iterator {
private:
    std::queue<Node*> queue_;
public:
    BFSIterator(Node* root) {
        if (root) queue_.push(root);
    }

    bool hasNext() override {
        return !queue_.empty();
    }

    int next() override {
        Node* node = queue.front();
        queue.pop();
        // 将子节点加入队列（如果是图，要加访问标记）
        for (Node* child : node->children) {
            if (child) queue_.push(child);
        }
        return node->value;
    }
};

class Tree {
private:
    Node* root_;
public:
    Tree(Node* root) : root_(root) {}

    std::unique_ptr<Iterator> createIterator(const std::string& type) {
        if (type == "dfs") {
            return std::make_unique<DFSIterator>(root_);
        } else if (type == "bfs") {
            return std::make_unique<BFSIterator>(root_);
        }
        return nullptr;
    }
};

Tree tree(root);
auto it = tree.createIterator("dfs");
while (it->hasNext()) {
    std::cout << it->next() << " ";
}