访问者模式 (Visitor Pattern)

访问者模式详解与应用
最新推荐文章于 2025-11-25 11:05:06 发布
原创 最新推荐文章于 2025-11-25 11:05:06 发布 · 391 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#访问者模式

1. 模式定义与核心思想
访问者模式表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

核心思想：

双重分发 (Double Dispatch)：通过两次多态调用来实现操作的选择。第一次选择访问者类型，第二次选择元素类型。

分离关注点：将数据结构与数据操作分离，将相关的操作集中到一个访问者对象中。

开闭原则：容易添加新的操作（新的访问者），但难以添加新的元素类型。

2. 模式结构（角色分析）
访问者模式包含五个主要角色：

Visitor (访问者接口)

为每个 ConcreteElement 类声明一个 visit 操作。

ConcreteVisitor (具体访问者)

实现每个由 Visitor 声明的操作。

每个操作实现算法的一部分，而该算法片段是对应于结构中对象的类。

Element (元素接口)

定义一个 accept 方法，以一个访问者作为参数。

ConcreteElement (具体元素)

实现 accept 方法，通常都是：visitor.visit(this)

ObjectStructure (对象结构)

能枚举它的元素。

可以提供一个高层的接口以允许访问者访问它的元素。

3. 经典C++实现示例
示例 1：几何图形处理（经典示例）
展示如何对不同的几何图形执行不同的操作。

#include <iostream>
#include <vector>
#include <memory>
#include <cmath>

// 前向声明
class Circle;
class Rectangle;
class Triangle;

// Visitor: 图形访问者接口
class ShapeVisitor {
public:
    virtual ~ShapeVisitor() = default;
    virtual void visit(Circle& circle) = 0;
    virtual void visit(Rectangle& rectangle) = 0;
    virtual void visit(Triangle& triangle) = 0;
};

// Element: 图形接口
class Shape {
public:
    virtual ~Shape() = default;
    virtual void accept(ShapeVisitor& visitor) = 0;
    virtual std::string getName() const = 0;
};

// ConcreteElement: 圆形
class Circle : public Shape {
private:
    double radius_;
public:
    Circle(double radius) : radius_(radius) {}
    
    void accept(ShapeVisitor& visitor) override {
        visitor.visit(*this);
    }
    
    std::string getName() const override { return "Circle"; }
    double getRadius() const { return radius_; }
    double getArea() const { return M_PI * radius_ * radius_; }
    double getPerimeter() const { return 2 * M_PI * radius_; }
};

// ConcreteElement: 矩形
class Rectangle : public Shape {
private:
    double width_, height_;
public:
    Rectangle(double width, double height) : width_(width), height_(height) {}
    
    void accept(ShapeVisitor& visitor) override {
        visitor.visit(*this);
    }
    
    std::string getName() const override { return "Rectangle"; }
    double getWidth() const { return width_; }
    double getHeight() const { return height_; }
    double getArea() const { return width_ * height_; }
    double getPerimeter() const { return 2 * (width_ + height_); }
};

// ConcreteElement: 三角形
class Triangle : public Shape {
private:
    double a_, b_, c_;
public:
    Triangle(double a, double b, double c) : a_(a), b_(b), c_(c) {}
    
    void accept(ShapeVisitor& visitor) override {
        visitor.visit(*this);
    }
    
    std::string getName() const override { return "Triangle"; }
    double getA() const { return a_; }
    double getB() const { return b_; }
    double getC() const { return c_; }
    double getArea() const {
        double s = (a_ + b_ + c_) / 2;
        return std::sqrt(s * (s - a_) * (s - b_) * (s - c_));
    }
    double getPerimeter() const { return a_ + b_ + c_; }
};

// ConcreteVisitor: 面积计算器
class AreaCalculator : public ShapeVisitor {
private:
    double totalArea_ = 0.0;
public:
    void visit(Circle& circle) override {
        double area = circle.getArea();
        std::cout << "Circle area: " << area << "\n";
        totalArea_ += area;
    }
    
    void visit(Rectangle& rectangle) override {
        double area = rectangle.getArea();
        std::cout << "Rectangle area: " << area << "\n";
        totalArea_ += area;
    }
    
    void visit(Triangle& triangle) override {
        double area = triangle.getArea();
        std::cout << "Triangle area: " << area << "\n";
        totalArea_ += area;
    }
    
    double getTotalArea() const { return totalArea_; }
    void reset() { totalArea_ = 0.0; }
};

// ConcreteVisitor: 周长计算器
class PerimeterCalculator : public ShapeVisitor {
private:
    double totalPerimeter_ = 0.0;
public:
    void visit(Circle& circle) override {
        double perimeter = circle.getPerimeter();
        std::cout << "Circle perimeter: " << perimeter << "\n";
        totalPerimeter_ += perimeter;
    }
    
    void visit(Rectangle& rectangle) override {
        double perimeter = rectangle.getPerimeter();
        std::cout << "Rectangle perimeter: " << perimeter << "\n";
        totalPerimeter_ += perimeter;
    }
    
    void visit(Triangle& triangle) override {
        double perimeter = triangle.getPerimeter();
        std::cout << "Triangle perimeter: " << perimeter << "\n";
        totalPerimeter_ += perimeter;
    }
    
    double getTotalPerimeter() const { return totalPerimeter_; }
    void reset() { totalPerimeter_ = 0.0; }
};

// ConcreteVisitor: 图形信息输出器
class ShapePrinter : public ShapeVisitor {
public:
    void visit(Circle& circle) override {
        std::cout << "Circle: radius = " << circle.getRadius() 
                  << ", area = " << circle.getArea() << "\n";
    }
    
    void visit(Rectangle& rectangle) override {
        std::cout << "Rectangle: " << rectangle.getWidth() << " x " << rectangle.getHeight()
                  << ", area = " << rectangle.getArea() << "\n";
    }
    
    void visit(Triangle& triangle) override {
        std::cout << "Triangle: sides = " << triangle.getA() << ", " 
                  << triangle.getB() << ", " << triangle.getC()
                  << ", area = " << triangle.getArea() << "\n";
    }
};

// ObjectStructure: 图形集合
class ShapeCollection {
private:
    std::vector<std::unique_ptr<Shape>> shapes_;
public:
    void addShape(std::unique_ptr<Shape> shape) {
        shapes_.push_back(std::move(shape));
    }
    
    void accept(ShapeVisitor& visitor) {
        for (auto& shape : shapes_) {
            shape->accept(visitor);
        }
    }
    
    size_t size() const { return shapes_.size(); }
};

// 客户端代码
int main() {
    ShapeCollection collection;
    
    // 添加各种图形
    collection.addShape(std::make_unique<Circle>(5.0));
    collection.addShape(std::make_unique<Rectangle>(4.0, 6.0));
    collection.addShape(std::make_unique<Triangle>(3.0, 4.0, 5.0));
    
    std::cout << "=== Shape Information ===\n";
    ShapePrinter printer;
    collection.accept(printer);
    
    std::cout << "\n=== Calculating Total Area ===\n";
    AreaCalculator areaCalc;
    collection.accept(areaCalc);
    std::cout << "Total area: " << areaCalc.getTotalArea() << "\n";
    
    std::cout << "\n=== Calculating Total Perimeter ===\n";
    PerimeterCalculator perimeterCalc;
    collection.accept(perimeterCalc);
    std::cout << "Total perimeter: " << perimeterCalc.getTotalPerimeter() << "\n";
    
    return 0;
}

示例 2：编译器抽象语法树（AST）处理
展示编译器中对不同语法节点的处理。

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

// 前向声明
class AssignmentNode;
class BinaryOpNode;
class NumberNode;
class VariableNode;

// Visitor: AST访问者接口
class ASTVisitor {
public:
    virtual ~ASTVisitor() = default;
    virtual void visit(AssignmentNode& node) = 0;
    virtual void visit(BinaryOpNode& node) = 0;
    virtual void visit(NumberNode& node) = 0;
    virtual void visit(VariableNode& node) = 0;
};

// Element: AST节点接口
class ASTNode {
public:
    virtual ~ASTNode() = default;
    virtual void accept(ASTVisitor& visitor) = 0;
};

// ConcreteElement: 赋值语句节点
class AssignmentNode : public ASTNode {
private:
    std::string varName_;
    std::unique_ptr<ASTNode> value_;
public:
    AssignmentNode(const std::string& varName, std::unique_ptr<ASTNode> value)
        : varName_(varName), value_(std::move(value)) {}
    
    void accept(ASTVisitor& visitor) override {
        visitor.visit(*this);
    }
    
    const std::string& getVarName() const { return varName_; }
    ASTNode* getValue() const { return value_.get(); }
};

// ConcreteElement: 二元操作节点
class BinaryOpNode : public ASTNode {
private:
    char op_;
    std::unique_ptr<ASTNode> left_;
    std::unique_ptr<ASTNode> right_;
public:
    BinaryOpNode(char op, std::unique_ptr<ASTNode> left, std::unique_ptr<ASTNode> right)
        : op_(op), left_(std::move(left)), right_(std::move(right)) {}
    
    void accept(ASTVisitor& visitor) override {
        visitor.visit(*this);
    }
    
    char getOp() const { return op_; }
    ASTNode* getLeft() const { return left_.get(); }
    ASTNode* getRight() const { return right_.get(); }
};

// ConcreteElement: 数字字面量节点
class NumberNode : public ASTNode {
private:
    int value_;
public:
    NumberNode(int value) : value_(value) {}
    
    void accept(ASTVisitor& visitor) override {
        visitor.visit(*this);
    }
    
    int getValue() const { return value_; }
};

// ConcreteElement: 变量引用节点
class VariableNode : public ASTNode {
private:
    std::string name_;
public:
    VariableNode(const std::string& name) : name_(name) {}
    
    void accept(ASTVisitor& visitor) override {
        visitor.visit(*this);
    }
    
    const std::string& getName() const { return name_; }
};

// ConcreteVisitor: 代码生成器
class CodeGenerator : public ASTVisitor {
private:
    int indentLevel_ = 0;
    
    void printIndent() {
        for (int i = 0; i < indentLevel_; ++i) {
            std::cout << "  ";
        }
    }
public:
    void visit(AssignmentNode& node) override {
        printIndent();
        std::cout << node.getVarName() << " = ";
        node.getValue()->accept(*this);
        std::cout << ";\n";
    }
    
    void visit(BinaryOpNode& node) override {
        std::cout << "(";
        node.getLeft()->accept(*this);
        std::cout << " " << node.getOp() << " ";
        node.getRight()->accept(*this);
        std::cout << ")";
    }
    
    void visit(NumberNode& node) override {
        std::cout << node.getValue();
    }
    
    void visit(VariableNode& node) override {
        std::cout << node.getName();
    }
};

// ConcreteVisitor: 类型检查器
class TypeChecker : public ASTVisitor {
public:
    void visit(AssignmentNode& node) override {
        std::cout << "Type checking assignment: " << node.getVarName() << "\n";
        node.getValue()->accept(*this);
    }
    
    void visit(BinaryOpNode& node) override {
        std::cout << "Type checking binary operation: " << node.getOp() << "\n";
        node.getLeft()->accept(*this);
        node.getRight()->accept(*this);
    }
    
    void visit(NumberNode& node) override {
        std::cout << "Found number literal: " << node.getValue() << " (type: int)\n";
    }
    
    void visit(VariableNode& node) override {
        std::cout << "Found variable reference: " << node.getName() << " (type: unknown)\n";
    }
};

// 构建AST: x = (a + 5) * 2
std::unique_ptr<ASTNode> createSampleAST() {
    // (a + 5)
    auto left = std::make_unique<BinaryOpNode>(
        '+',
        std::make_unique<VariableNode>("a"),
        std::make_unique<NumberNode>(5)
    );
    
    // (a + 5) * 2
    auto expr = std::make_unique<BinaryOpNode>(
        '*',
        std::move(left),
        std::make_unique<NumberNode>(2)
    );
    
    // x = (a + 5) * 2
    return std::make_unique<AssignmentNode>(
        "x",
        std::move(expr)
    );
}

// 客户端代码
int main() {
    auto ast = createSampleAST();
    
    std::cout << "=== Code Generation ===\n";
    CodeGenerator codeGen;
    ast->accept(codeGen);
    
    std::cout << "\n=== Type Checking ===\n";
    TypeChecker typeChecker;
    ast->accept(typeChecker);
    
    return 0;
}

示例 3：文档导出系统
展示将文档内容导出为不同格式。

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

// 前向声明
class TextElement;
class ImageElement;
class TableElement;

// Visitor: 文档导出器接口
class DocumentExporter {
public:
    virtual ~DocumentExporter() = default;
    virtual void visit(TextElement& element) = 0;
    virtual void visit(ImageElement& element) = 0;
    virtual void visit(TableElement& element) = 0;
    virtual std::string getResult() const = 0;
};

// Element: 文档元素接口
class DocumentElement {
public:
    virtual ~DocumentElement() = default;
    virtual void accept(DocumentExporter& exporter) = 0;
};

// ConcreteElement: 文本元素
class TextElement : public DocumentElement {
private:
    std::string content_;
public:
    TextElement(const std::string& content) : content_(content) {}
    
    void accept(DocumentExporter& exporter) override {
        exporter.visit(*this);
    }
    
    const std::string& getContent() const { return content_; }
};

// ConcreteElement: 图片元素
class ImageElement : public DocumentElement {
private:
    std::string src_;
    int width_, height_;
public:
    ImageElement(const std::string& src, int width, int height)
        : src_(src), width_(width), height_(height) {}
    
    void accept(DocumentExporter& exporter) override {
        exporter.visit(*this);
    }
    
    const std::string& getSrc() const { return src_; }
    int getWidth() const { return width_; }
    int getHeight() const { return height_; }
};

// ConcreteElement: 表格元素
class TableElement : public DocumentElement {
private:
    std::vector<std::vector<std::string>> data_;
public:
    TableElement(const std::vector<std::vector<std::string>>& data) : data_(data) {}
    
    void accept(DocumentExporter& exporter) override {
        exporter.visit(*this);
    }
    
    const std::vector<std::vector<std::string>>& getData() const { return data_; }
};

// ConcreteVisitor: HTML导出器
class HTMLExporter : public DocumentExporter {
private:
    std::string result_;
public:
    void visit(TextElement& element) override {
        result_ += "<p>" + element.getContent() + "</p>\n";
    }
    
    void visit(ImageElement& element) override {
        result_ += "<img src=\"" + element.getSrc() + "\" width=\"" 
                 + std::to_string(element.getWidth()) + "\" height=\""
                 + std::to_string(element.getHeight()) + "\">\n";
    }
    
    void visit(TableElement& element) override {
        result_ += "<table border=\"1\">\n";
        for (const auto& row : element.getData()) {
            result_ += "  <tr>\n";
            for (const auto& cell : row) {
                result_ += "    <td>" + cell + "</td>\n";
            }
            result_ += "  </tr>\n";
        }
        result_ += "</table>\n";
    }
    
    std::string getResult() const override { return result_; }
};

// ConcreteVisitor: Markdown导出器
class MarkdownExporter : public DocumentExporter {
private:
    std::string result_;
public:
    void visit(TextElement& element) override {
        result_ += element.getContent() + "\n\n";
    }
    
    void visit(ImageElement& element) override {
        result_ += "![" + element.getSrc() + "](" + element.getSrc() + ")\n\n";
    }
    
    void visit(TableElement& element) override {
        const auto& data = element.getData();
        if (data.empty()) return;
        
        // 表头
        for (size_t i = 0; i < data[0].size(); ++i) {
            result_ += "| " + data[0][i] + " ";
        }
        result_ += "|\n";
        
        // 分隔线
        for (size_t i = 0; i < data[0].size(); ++i) {
            result_ += "| --- ";
        }
        result_ += "|\n";
        
        // 数据行
        for (size_t i = 1; i < data.size(); ++i) {
            for (const auto& cell : data[i]) {
                result_ += "| " + cell + " ";
            }
            result_ += "|\n";
        }
        result_ += "\n";
    }
    
    std::string getResult() const override { return result_; }
};

// 文档对象
class Document {
private:
    std::vector<std::unique_ptr<DocumentElement>> elements_;
public:
    void addElement(std::unique_ptr<DocumentElement> element) {
        elements_.push_back(std::move(element));
    }
    
    std::string exportDocument(DocumentExporter& exporter) {
        for (auto& element : elements_) {
            element->accept(exporter);
        }
        return exporter.getResult();
    }
};

// 客户端代码
int main() {
    Document doc;
    
    // 添加文档元素
    doc.addElement(std::make_unique<TextElement>("This is a sample document"));
    doc.addElement(std::make_unique<ImageElement>("image.jpg", 800, 600));
    
    std::vector<std::vector<std::string>> tableData = {
        {"Name", "Age", "City"},
        {"Alice", "25", "New York"},
        {"Bob", "30", "London"}
    };
    doc.addElement(std::make_unique<TableElement>(tableData));
    
    // 导出为HTML
    HTMLExporter htmlExporter;
    std::string html = doc.exportDocument(htmlExporter);
    std::cout << "=== HTML Export ===\n" << html << "\n";
    
    // 导出为Markdown
    MarkdownExporter mdExporter;
    std::string markdown = doc.exportDocument(mdExporter);
    std::cout << "=== Markdown Export ===\n" << markdown << "\n";
    
    return 0;
}

4. 访问者模式的优缺点
优点：

开闭原则：容易添加新的操作（新的访问者）。

单一职责原则：将相关操作集中在一个访问者中。

访问者可以累积状态：可以在遍历过程中收集信息。

算法集中化：相关的行为不是分散在各个元素类中。

缺点：

难以添加新的元素类型：每添加一个新的元素类型，都要修改所有访问者。

破坏封装性：访问者通常需要访问元素的内部细节。

元素接口依赖访问者：元素接口必须提供 accept 方法。

可能违反迪米特法则：访问者需要了解具体元素类的细节。

5. 适用场景
对象结构稳定：但需要在此结构上定义新的操作。

需要对一个对象结构中的对象进行很多不同且不相关的操作。

需要避免污染元素类：不希望这些操作"污染"这些元素的类。

编译器、解释器：AST遍历、类型检查、代码生成等。

文档处理：导出为不同格式、语法高亮等。

访问者模式通过双重分发机制，提供了强大的扩展能力，特别适合于需要对复杂对象结构执行多种不同操作的场景。

访问者模式（Visitor Pattern）
qq_42889517的博客
05-05 1004
✅ 将操作封装到独立的访问者类中，避免修改原有类结构，符合开闭原则。✅ 适用于需要在一个不常变化的对象结构上，动态增加新操作的场景。如果你对访问者模式有其他问题或想了解更多细节，欢迎继续提问！
设计模式 22 访问者模式 Visitor Pattern
jxusthusiwen的专栏
05-28 1229
访问者模式是一种行为型设计模式，它允许你在不改变已有类结构的情况下，为一组对象添加新的操作。它将算法与对象结构分离，使你能够在不修改现有类的情况下，为这些类添加新的操作。访问者模式是一种强大的设计模式，但需要谨慎使用。在实施访问者模式时，需要仔细考虑元素接口和访问者接口的设计，以及具体访问者类的实现。同时，需要了解访问者模式的局限性，并选择合适的应用场景。
访问者模式 Visitor Pattern
木易
02-20 269
一、模式介绍 1.1、定义 将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方法。 它将对数据的操作与数据结构进行分离，是行为模式中最复杂的一种模式。 1.2、优点 扩展性好。能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能 复用性好。可以通过访问者来定义整个对象结构通用的功能，从而提高系统的复用程度 灵活性好。访问者模式将数据结构与作用于结构上的操作解耦，使得操作集合可相对自由
7.9 访问者模式 (Visitor Pattern)
NorthStar的博客
07-25 765
访问者模式
Java设计模式（二十一）行为型- 访问者模式 Visitor Pattern（史上最全访问者模式）与使用场景以及优缺点
移动端开发与最新技术
05-19 681
访问者模式
设计模式：访问者模式（Visitor Pattern）
TechNomad的博客
09-08 1271
访问者模式是一种行为型设计模式，它将数据结构与对数据的操作分离。通过在不改变数据结构的前提下，定义作用于这些数据结构的新操作。
设计模式 -- 访问者模式（Visitor Pattern）
魔法师之家
03-23 8133
封装一些作用于某些数据结构中的各元素的操作，它可以在不改变数据结构的前提下赋予这些元素新的操作。 应用场景 对象结构比较稳定，但是需要在对象结构的基础上定义新的操作。 需要对同一个类的不同对象执行不不同的操作，但是不希望增加操作的时候改变这些类。 总结 准确识别出Visitor实用的场景，如果一个对象结构不稳定决不可使用，不然在增删元素时改动将非常巨大。 对象结构中的元素要可以迭代访问 Visitor里一般存在与元素个数相同的visit方法。 元
设计模式【访问者模式VisitorPattern】
11-11 404
访问者模式 在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。 介绍 意图：主要将数据结构与数据操作分离。 主要解决：稳定的数据结构和易变的操作耦合问题。
设计模式-访问者模式-Visitor Pattern
wesigj的博客
09-09 1365
访问者模式提供了一种将操作和对象结构分离的方法，使得你可以在不修改对象结构的情况下增加新操作。这种模式在处理复杂对象结构和需要动态添加操作的场景中非常有用。访问者模式是一种强大的模式，它允许你向对象结构添加新的操作而不需要修改对象结构本身。然而，它也带来了一些缺点，如增加系统复杂性和维护难度。因此，在决定使用访问者模式时，需要权衡其优缺点，确保它适合你的应用场景。通常，当对象结构相对稳定，而需要对结构中的元素执行多种操作时，访问者模式是一个不错的选择。
设计模式-21访问者模式Visitor Pattern
d3y1`5 81_09
09-16 866
访问者模式是一种行为型设计模式，允许在不修改已有类结构的情况下添加新操作。该模式将算法与操作对象分离，适用于需要在不改变对象类的前提下定义新操作（如显示、价格计算、维护等）的场景。通过访问者接口和具体访问者实现（如ComputerPartDisplayVisitor、ComputerPartPriceVisitor），可以对复杂对象结构（如计算机部件）执行不同操作。当对象结构稳定但经常需要新增操作时，访问者模式能有效避免"污染"原有类代码。
访问者模式VisitorPattern
10-08
**访问者模式(VisitorPattern)** 访问者模式是一种行为设计模式，它使你能在不修改对象结构的前提下向对象添加新的操作。这种模式常用于处理具有复杂逻辑的对象结构，特别是当你需要对这些对象进行多态操作时。访问...
访问者模式(VisitorPattern)
01-27
访问者模式（VisitorPattern）是一种行为设计模式，其主要目的是为了在不改变数据结构的前提下，增加对元素集合的新操作。这种模式将操作封装在独立的访问者类中，使得操作和数据结构解耦，允许两者独立演进。 **...
设计模式-访问者模式
libing__123的博客
11-25 188
角色：元素，访问者，数据结构。数据结构对应模块，元素对应功能，算法对应访问者。给一个模块的若干功能同时扩展算法。
从平台“建而无用”到服务升级，政府部门借助AI驱动的技术转移平台能实现多大跨越？.docx
12-02
从平台“建而无用”到服务升级，政府部门借助AI驱动的技术转移平台能实现多大跨越？
SPIKE高阶-圣诞节活动课-雪域漫步
12-02
手部和滑雪杖组成的连杆部分，对孔位要求比较严格，需按照搭建步骤图进行搭建。 l圣诞帽为装饰部分，老师可根据实际情况选择是否搭建圣诞帽。（资料中单独提供了圣诞帽的搭建步骤图） if多重结构的执行顺序：从上向下依次检测判断条件，如果某一个判断条件成立，则执行其对应的语句，之后不在向下执行。只有当所有的判断条件都不成立时，程序才会执行else分支中的语句。elif分支可以有任意多个，else分支可以省略。（if多重结构执行一次，最多只有一个语句块被执行） 这个是属于spikepython的课程，但是积木块普通spike也是可以上的，ppt引入，搭建图，运行视频，都有
基于 Transformer 的英译中翻译项目实战
12-02
基于 Transformer 的英译中翻译项目实战
kxqabc_path_planning_48964_1764660215940.zip
12-02
kxqabc_path_planning_48964_1764660215940.zip
如何通过“智改数转”一体化服务打造产业升级，并打造赢得客户信赖？.docx
12-02
如何通过“智改数转”一体化服务打造产业升级，并打造赢得客户信赖？
基于GUI界面的Python热量摄入与消耗统计分析系统源码及可执行程序
最新发布
12-02
基于图形用户界面的膳食能量摄入与消耗数据追踪系统开发资源包。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值