{"title":"Visitor Design Pattern","description":null,"content":"\n> **DEFINITION**\n>\n> The **Visitor Design Pattern** is a **behavioral pattern** that lets you **add new operations to existing object structures** without modifying their classes.\n\n\nIt achieves this by allowing you to separate the algorithm from the objects it operates on.\n\nIt’s particularly useful in situations where:\n\n- You have a **complex object structure** (like ASTs, documents, or UI elements) that you want to **perform multiple unrelated operations** on.\n- You want to **add new behaviors** to classes without changing their source code.\n- You need to **perform different actions depending on an object’s concrete type**, without resorting to a long chain of `if-else` or `instanceof` checks.\n\nLet’s walk through a real-world example to see how we can apply the Visitor Pattern to cleanly separate behavior from structure and make our system easier to extend without touching existing classes.\n\n---\n\n# 1. The Problem: Adding Operations to a Shape Hierarchy\n\nImagine you are building a vector graphics editor that supports multiple shape types:\n\n- `Circle`\n- `Rectangle`\n\nEach shape is part of a common hierarchy and must support a variety of operations, such as:\n\n- **Rendering** on screen\n- **Calculating area**\n- **Exporting to SVG**\n- **Serializing to JSON**\n\nThe simplest approach is to add all of these methods to each shape class:\n\n\n```java\ninterface Shape {\n void draw();\n double calculateArea();\n String exportAsSvg();\n String toJson();\n}\n```\n\n```python\nclass Shape(ABC):\n @abstractmethod\n def draw(self):\n pass\n \n @abstractmethod\n def calculate_area(self):\n pass\n \n @abstractmethod\n def export_as_svg(self):\n pass\n \n @abstractmethod\n def to_json(self):\n pass\n```\n\n```cpp\nclass Shape {\npublic:\n virtual void draw() = 0;\n virtual double calculateArea() = 0;\n virtual const char* exportAsSvg() = 0;\n virtual const char* toJson() = 0;\n virtual ~Shape() {}\n};\n```\n\n```go\ntype Shape interface {\n\tDraw()\n\tCalculateArea() float64\n\tExportAsSvg() string\n\tToJson() string\n}\n```\n\n```csharp\ninterface IShape\n{\n void Draw();\n double CalculateArea();\n string ExportAsSvg();\n string ToJson();\n}\n```\n\n```typescript\ninterface Shape {\n draw(): void;\n calculateArea(): number;\n exportAsSvg(): string;\n toJson(): string;\n}\n```\n\n\n\n```java\nclass Circle implements Shape {\n private double radius;\n\n public Circle(double radius) {\n this.radius = radius;\n }\n\n public void draw() {\n System.out.println(\"Drawing a circle\");\n }\n\n public double calculateArea() {\n return Math.PI * radius * radius;\n }\n\n public String exportAsSvg() {\n return \"\";\n }\n\n public String toJson() {\n return \"{ \\\"type\\\": \\\"circle\\\", \\\"radius\\\": \" + radius + \" }\";\n }\n}\n```\n\n```python\nclass Circle(Shape):\n def __init__(self, radius):\n self.radius = radius\n \n def draw(self):\n print(\"Drawing a circle\")\n \n def calculate_area(self):\n return math.pi * self.radius * self.radius\n \n def export_as_svg(self):\n return f''\n \n def to_json(self):\n return f'{{ \"type\": \"circle\", \"radius\": {self.radius} }}'\n```\n\n```cpp\nclass Circle : public Shape {\nprivate:\n double radius;\n char svgBuffer[100];\n char jsonBuffer[100];\n\npublic:\n Circle(double r) {\n radius = r;\n // Initialize buffers\n svgBuffer[0] = '\\0';\n jsonBuffer[0] = '\\0';\n }\n\n void draw() {\n std::cout << \"Drawing a circle\\n\";\n }\n\n double calculateArea() {\n return 3.141592653589793 * radius * radius;\n }\n\n const char* exportAsSvg() {\n sprintf(svgBuffer, \"\", radius);\n return svgBuffer;\n }\n\n const char* toJson() {\n sprintf(jsonBuffer, \"{ \\\"type\\\": \\\"circle\\\", \\\"radius\\\": %.2f }\", radius);\n return jsonBuffer;\n }\n};\n```\n\n```go\ntype Circle struct {\n\tradius float64\n}\n\nfunc NewCircle(radius float64) *Circle {\n\treturn &Circle{radius: radius}\n}\n\nfunc (c *Circle) Draw() {\n\tprintln(\"Drawing a circle\")\n}\n\nfunc (c *Circle) CalculateArea() float64 {\n\treturn 3.141592653589793 * c.radius * c.radius\n}\n\nfunc (c *Circle) ExportAsSvg() string {\n\treturn \"\"\n}\n\nfunc (c *Circle) ToJson() string {\n\treturn \"{ \\\"type\\\": \\\"circle\\\", \\\"radius\\\": \" + fmt.Sprint(c.radius) + \" }\"\n}\n```\n\n```csharp\nclass Circle : IShape\n{\n private double radius;\n\n public Circle(double radius)\n {\n this.radius = radius;\n }\n\n public void Draw()\n {\n Console.WriteLine(\"Drawing a circle\");\n }\n\n public double CalculateArea()\n {\n return Math.PI * radius * radius;\n }\n\n public string ExportAsSvg()\n {\n return \"\";\n }\n\n public string ToJson()\n {\n return \"{ \\\"type\\\": \\\"circle\\\", \\\"radius\\\": \" + radius + \" }\";\n }\n}\n```\n\n```typescript\nclass Circle implements Shape {\n private radius: number;\n\n constructor(radius: number) {\n this.radius = radius;\n }\n\n draw(): void {\n console.log(\"Drawing a circle\");\n }\n\n calculateArea(): number {\n return Math.PI * this.radius * this.radius;\n }\n\n exportAsSvg(): string {\n return \"\";\n }\n\n toJson(): string {\n return \"{ \\\"type\\\": \\\"circle\\\", \\\"radius\\\": \" + this.radius + \" }\";\n }\n}\n```\n\n\n### Why This Breaks Down\n\nThis solution seems fine for a couple of operations, but quickly becomes problematic as new operations or shape types are added.\n\n#### 1. Violates the Single Responsibility Principle\n\nEach shape class now contains multiple unrelated responsibilities: geometry calculations, drawing, serialization, and format exporting. This bloats the class and makes it harder to maintain.\n\n#### 2. Hard to Extend\n\nIf you need to add a new operation (e.g., `generatePdf()`), you must modify every class in the hierarchy, recompile everything, and risk breaking existing logic. This violates the Open/Closed Principle.\n\n#### 3. You Don’t Always Control the Classes\n\nWhat if the shape classes are part of a third-party library or generated code? You cannot easily add new behavior directly.\n\n### What We Really Need\n\nWe need a solution that lets us:\n\n- **Separate operations** from the shape classes\n- Add new behaviors **without modifying existing classes**\n- Avoid duplicating `instanceof` checks or using type switches to handle different shapes\n\nThis is exactly what the Visitor pattern is designed to solve.\n\n---\n\n# 2. What is the Visitor Pattern\n\n> The **Visitor Design Pattern** lets you **separate algorithms from the objects on which they operate**. It enables you to **add new operations** to a class hierarchy **without modifying the classes themselves**.\n\nTwo characteristics define the pattern:\n\n1. **Separation of algorithm and structure:** The data classes (elements) stay clean. All operational logic lives in visitor classes that are entirely separate from the element hierarchy.\n2. **Double dispatch:** The correct method to call is determined by both the type of the element and the type of the visitor. The element calls back the visitor with `this`, which resolves the element's concrete type at compile time. This two-step dispatch is what makes the pattern work without `instanceof` checks.\n\n\n> **Real-World Analogy**\n>\n> Think about a home inspection. You have a house with different components: plumbing, electrical wiring, structural framing, and HVAC. Each specialist (a plumber, an electrician, a structural engineer, an HVAC technician) \"visits\" the house and inspects only what they understand. \n>\n> The house does not need to know how to evaluate its own plumbing or wiring. It just opens the door and lets each inspector do their job. Adding a new type of inspection (say, a fire safety audit) does not require remodeling the house. You just bring in a new inspector. \n>\n> The Visitor pattern works the same way: the elements (house components) accept visitors (inspectors), and new operations are new visitors.\n\n\n---\n\n## Class Diagram\n\n\n```mermaid\nclassDiagram\n class Element {\n <>\n +accept(Visitor)\n }\n\n class ConcreteElementA {\n +accept(Visitor)\n +operationA()\n }\n\n class ConcreteElementB {\n +accept(Visitor)\n +operationB()\n }\n\n class Visitor {\n <>\n +visitElementA(ConcreteElementA)\n +visitElementB(ConcreteElementB)\n }\n\n class ConcreteVisitor1 {\n +visitElementA(ConcreteElementA)\n +visitElementB(ConcreteElementB)\n }\n\n class ConcreteVisitor2 {\n +visitElementA(ConcreteElementA)\n +visitElementB(ConcreteElementB)\n }\n\n Element <|.. ConcreteElementA\n Element <|.. ConcreteElementB\n Visitor <|.. ConcreteVisitor1\n Visitor <|.. ConcreteVisitor2\n Element --> Visitor : accepts\n\n style Element fill:#00ceff,stroke:#000,color:#000\n style ConcreteElementA fill:#ffa94d,stroke:#000,color:#000\n style ConcreteElementB fill:#ffa94d,stroke:#000,color:#000\n style Visitor fill:#00ceff,stroke:#000,color:#000\n style ConcreteVisitor1 fill:#38d9a9,stroke:#000,color:#000\n style ConcreteVisitor2 fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### 1. Element (Interface)\n\nDeclares the `accept(Visitor)` method that every element in the object structure must implement. This is the entry point for the double dispatch mechanism.\n\nThe `accept()` method exists purely to enable double dispatch. Without it, the visitor would need `instanceof` checks to figure out the element's concrete type. With it, the element tells the visitor \"I am a Circle\" by calling `visitor.visitCircle(this)`, and the correct overloaded method is invoked at compile time.\n\n### 2. Concrete Elements (e.g., `Circle`, `Rectangle`)\n\nEach concrete element implements the `accept()` method by calling the visitor's corresponding visit method, passing `this`.\n\n### 3. Visitor (Interface)\n\nDeclares a `visit` method for each concrete element type. This is the interface that all operations implement.\n\n### 4. Concrete Visitors (e.g., `AreaCalculatorVisitor`)\n\nEach concrete visitor implements the Visitor interface with a specific operation. One visitor might calculate areas, another might export to SVG, a third might validate constraints.\n\n---\n\n# 3. How It Works\n\nThe Visitor workflow involves a two-step dispatch that routes execution to the right method based on both the element type and the visitor type.\n\n\n```mermaid\nsequenceDiagram\n participant Client\n participant Circle\n participant Rectangle\n participant AreaVisitor as AreaCalculatorVisitor\n\n Client->>Circle: accept(areaVisitor)\n Circle->>AreaVisitor: visitCircle(this)\n AreaVisitor-->>Circle: (calculates area)\n\n Client->>Rectangle: accept(areaVisitor)\n Rectangle->>AreaVisitor: visitRectangle(this)\n AreaVisitor-->>Rectangle: (calculates area)\n```\n\n\n**Step 1:** The client creates a concrete visitor (e.g., `AreaCalculatorVisitor`).\n\n**Step 2:** The client iterates over the element collection and calls `element.accept(visitor)` on each one.\n\n**Step 3:** Inside `accept()`, the element calls back the visitor's specific method: `visitor.visitCircle(this)` for a Circle, `visitor.visitRectangle(this)` for a Rectangle. This is the double dispatch: the element resolves its own type.\n\n**Step 4:** The visitor's `visitCircle()` or `visitRectangle()` method runs, performing the operation using the element's data.\n\n**Step 5:** To add a new operation, you create a new visitor class. No element classes change.\n\n---\n\n# 4. Implementing Visitor Pattern\n\nLet us refactor the graphics system using the Visitor pattern to perform two operations (area calculation and SVG export) without putting any operational logic inside the shape classes.\n\nHere is the class diagram for the solution:\n\n\n```mermaid\nclassDiagram\n class Shape {\n <>\n +accept(ShapeVisitor)\n }\n\n class Circle {\n -radius: double\n +getRadius(): double\n +accept(ShapeVisitor)\n }\n\n class Rectangle {\n -width: double\n -height: double\n +getWidth(): double\n +getHeight(): double\n +accept(ShapeVisitor)\n }\n\n class ShapeVisitor {\n <>\n +visitCircle(Circle)\n +visitRectangle(Rectangle)\n }\n\n class AreaCalculatorVisitor {\n +visitCircle(Circle)\n +visitRectangle(Rectangle)\n }\n\n class SvgExporterVisitor {\n +visitCircle(Circle)\n +visitRectangle(Rectangle)\n }\n\n Shape <|.. Circle\n Shape <|.. Rectangle\n ShapeVisitor <|.. AreaCalculatorVisitor\n ShapeVisitor <|.. SvgExporterVisitor\n Shape --> ShapeVisitor : accepts\n\n style Shape fill:#00ceff,stroke:#000,color:#000\n style Circle fill:#ffa94d,stroke:#000,color:#000\n style Rectangle fill:#ffa94d,stroke:#000,color:#000\n style ShapeVisitor fill:#00ceff,stroke:#000,color:#000\n style AreaCalculatorVisitor fill:#38d9a9,stroke:#000,color:#000\n style SvgExporterVisitor fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### Step 1: Define the Shape Interface (Element)\n\nAll shapes must accept a visitor.\n\n\n```java\ninterface Shape {\n void accept(ShapeVisitor visitor);\n}\n```\n\n```python\nclass Shape(ABC):\n @abstractmethod\n def accept(self, visitor):\n pass\n```\n\n```cpp\nclass Shape {\npublic:\n virtual void accept(ShapeVisitor* visitor) = 0;\n virtual ~Shape() {}\n};\n```\n\n```go\ntype Shape interface {\n\tAccept(visitor ShapeVisitor)\n}\n```\n\n```csharp\ninterface IShape\n{\n void Accept(IShapeVisitor visitor);\n}\n```\n\n```typescript\ninterface Shape {\n accept(visitor: ShapeVisitor): void;\n}\n```\n\n\n### Step 2: Create Concrete Shape Classes (Elements)\n\nEach shape class implements `accept()` and delegates to the visitor.\n\n#### Circle\n\n\n```java\nclass Circle implements Shape {\n private final double radius;\n\n public Circle(double radius) {\n this.radius = radius;\n }\n\n public double getRadius() {\n return radius;\n }\n\n @Override\n public void accept(ShapeVisitor visitor) {\n visitor.visitCircle(this);\n }\n}\n```\n\n```python\nclass Circle(Shape):\n def __init__(self, radius):\n self._radius = radius\n \n def get_radius(self):\n return self._radius\n \n def accept(self, visitor):\n visitor.visit_circle(self)\n```\n\n```cpp\nclass Circle : public Shape {\nprivate:\n double radius;\n\npublic:\n Circle(double r) : radius(r) {}\n\n double getRadius() const {\n return radius;\n }\n\n void accept(ShapeVisitor* visitor) override;\n};\n```\n\n```go\ntype Circle struct {\n\tradius float64\n}\n\nfunc NewCircle(radius float64) *Circle {\n\treturn &Circle{radius: radius}\n}\n\nfunc (c *Circle) GetRadius() float64 {\n\treturn c.radius\n}\n\nfunc (c *Circle) Accept(visitor ShapeVisitor) {\n\tvisitor.VisitCircle(c)\n}\n```\n\n```csharp\nclass Circle : IShape\n{\n private readonly double radius;\n\n public Circle(double radius)\n {\n this.radius = radius;\n }\n\n public double GetRadius()\n {\n return radius;\n }\n\n public void Accept(IShapeVisitor visitor)\n {\n visitor.VisitCircle(this);\n }\n}\n```\n\n```typescript\nclass Circle implements Shape {\n private readonly radius: number;\n\n constructor(radius: number) {\n this.radius = radius;\n }\n\n getRadius(): number {\n return this.radius;\n }\n\n accept(visitor: ShapeVisitor): void {\n visitor.visitCircle(this);\n }\n}\n```\n\n\n#### Rectangle\n\n\n```java\nclass Rectangle implements Shape {\n private final double width;\n private final double height;\n\n public Rectangle(double width, double height) {\n this.width = width;\n this.height = height;\n }\n\n public double getWidth() {\n return width;\n }\n\n public double getHeight() {\n return height;\n }\n\n @Override\n public void accept(ShapeVisitor visitor) {\n visitor.visitRectangle(this);\n }\n}\n```\n\n```python\nclass Rectangle(Shape):\n def __init__(self, width, height):\n self._width = width\n self._height = height\n \n def get_width(self):\n return self._width\n \n def get_height(self):\n return self._height\n \n def accept(self, visitor):\n visitor.visit_rectangle(self)\n```\n\n```cpp\nclass Rectangle : public Shape {\nprivate:\n double width;\n double height;\n\npublic:\n Rectangle(double w, double h) : width(w), height(h) {}\n\n double getWidth() const {\n return width;\n }\n\n double getHeight() const {\n return height;\n }\n\n void accept(ShapeVisitor* visitor) override;\n};\n```\n\n```go\ntype Rectangle struct {\n\twidth float64\n\theight float64\n}\n\nfunc NewRectangle(width, height float64) *Rectangle {\n\treturn &Rectangle{width: width, height: height}\n}\n\nfunc (r *Rectangle) GetWidth() float64 {\n\treturn r.width\n}\n\nfunc (r *Rectangle) GetHeight() float64 {\n\treturn r.height\n}\n\nfunc (r *Rectangle) Accept(visitor ShapeVisitor) {\n\tvisitor.VisitRectangle(r)\n}\n```\n\n```csharp\nclass Rectangle : IShape\n{\n private readonly double width;\n private readonly double height;\n\n public Rectangle(double width, double height)\n {\n this.width = width;\n this.height = height;\n }\n\n public double GetWidth()\n {\n return width;\n }\n\n public double GetHeight()\n {\n return height;\n }\n\n public void Accept(IShapeVisitor visitor)\n {\n visitor.VisitRectangle(this);\n }\n}\n```\n\n```typescript\nclass Rectangle implements Shape {\n private readonly width: number;\n private readonly height: number;\n\n constructor(width: number, height: number) {\n this.width = width;\n this.height = height;\n }\n\n getWidth(): number {\n return this.width;\n }\n\n getHeight(): number {\n return this.height;\n }\n\n accept(visitor: ShapeVisitor): void {\n visitor.visitRectangle(this);\n }\n}\n```\n\n\n### Step 3: Define the Visitor Interface\n\nEach method corresponds to a shape type.\n\n\n```java\ninterface ShapeVisitor {\n void visitCircle(Circle circle);\n void visitRectangle(Rectangle rectangle);\n}\n```\n\n```python\nclass ShapeVisitor(ABC):\n @abstractmethod\n def visit_circle(self, circle):\n pass\n \n @abstractmethod\n def visit_rectangle(self, rectangle):\n pass\n```\n\n```cpp\nclass ShapeVisitor {\npublic:\n virtual void visitCircle(Circle* circle) = 0;\n virtual void visitRectangle(Rectangle* rectangle) = 0;\n virtual ~ShapeVisitor() {}\n};\n```\n\n```go\ntype ShapeVisitor interface {\n\tVisitCircle(circle Circle)\n\tVisitRectangle(rectangle Rectangle)\n}\n```\n\n```csharp\ninterface IShapeVisitor\n{\n void VisitCircle(Circle circle);\n void VisitRectangle(Rectangle rectangle);\n}\n```\n\n```typescript\ninterface ShapeVisitor {\n visitCircle(circle: Circle): void;\n visitRectangle(rectangle: Rectangle): void;\n}\n```\n\n\n### Step 4: Implement Concrete Visitors\n\n#### Area Calculator Visitor\n\n\n```java\nclass AreaCalculatorVisitor implements ShapeVisitor {\n @Override\n public void visitCircle(Circle circle) {\n double area = Math.PI * circle.getRadius() * circle.getRadius();\n System.out.println(\"Area of Circle: \" + area);\n }\n\n @Override\n public void visitRectangle(Rectangle rectangle) {\n double area = rectangle.getWidth() * rectangle.getHeight();\n System.out.println(\"Area of Rectangle: \" + area);\n }\n}\n```\n\n```python\nclass AreaCalculatorVisitor(ShapeVisitor):\n def visit_circle(self, circle):\n area = math.pi * circle.get_radius() * circle.get_radius()\n print(f\"Area of Circle: {area}\")\n \n def visit_rectangle(self, rectangle):\n area = rectangle.get_width() * rectangle.get_height()\n print(f\"Area of Rectangle: {area}\")\n```\n\n```cpp\nclass AreaCalculatorVisitor : public ShapeVisitor {\npublic:\n void visitCircle(Circle* circle) override {\n double area = 3.141592653589793 * circle->getRadius() * circle->getRadius();\n printf(\"Area of Circle: %.2f\\n\", area);\n }\n\n void visitRectangle(Rectangle* rectangle) override {\n double area = rectangle->getWidth() * rectangle->getHeight();\n printf(\"Area of Rectangle: %.2f\\n\", area);\n }\n};\n```\n\n```go\ntype AreaCalculatorVisitor struct{}\n\nfunc (v *AreaCalculatorVisitor) VisitCircle(circle *Circle) {\n\tarea := math.Pi * circle.GetRadius() * circle.GetRadius()\n\tfmt.Println(\"Area of Circle: \" + fmt.Sprint(area))\n}\n\nfunc (v *AreaCalculatorVisitor) VisitRectangle(rectangle *Rectangle) {\n\tarea := rectangle.GetWidth() * rectangle.GetHeight()\n\tfmt.Println(\"Area of Rectangle: \" + fmt.Sprint(area))\n}\n```\n\n```csharp\nclass AreaCalculatorVisitor : IShapeVisitor\n{\n public void VisitCircle(Circle circle)\n {\n double area = Math.PI * circle.GetRadius() * circle.GetRadius();\n Console.WriteLine(\"Area of Circle: \" + area);\n }\n\n public void VisitRectangle(Rectangle rectangle)\n {\n double area = rectangle.GetWidth() * rectangle.GetHeight();\n Console.WriteLine(\"Area of Rectangle: \" + area);\n }\n}\n```\n\n```typescript\nclass AreaCalculatorVisitor implements ShapeVisitor {\n visitCircle(circle: Circle): void {\n const area = Math.PI * circle.getRadius() * circle.getRadius();\n console.log(\"Area of Circle: \" + area);\n }\n\n visitRectangle(rectangle: Rectangle): void {\n const area = rectangle.getWidth() * rectangle.getHeight();\n console.log(\"Area of Rectangle: \" + area);\n }\n}\n```\n\n\n#### SVG Exporter Visitor\n\n\n```java\nclass SvgExporterVisitor implements ShapeVisitor {\n @Override\n public void visitCircle(Circle circle) {\n System.out.println(\"\");\n }\n\n @Override\n public void visitRectangle(Rectangle rectangle) {\n System.out.println(\"\");\n }\n}\n```\n\n```python\nclass SvgExporterVisitor(ShapeVisitor):\n def visit_circle(self, circle):\n print(f'')\n \n def visit_rectangle(self, rectangle):\n print(f'')\n```\n\n```cpp\nclass SvgExporterVisitor : public ShapeVisitor {\npublic:\n void visitCircle(Circle* circle) override {\n printf(\"\\n\", circle->getRadius());\n }\n\n void visitRectangle(Rectangle* rectangle) override {\n printf(\"\\n\",\n rectangle->getWidth(), rectangle->getHeight());\n }\n};\n```\n\n```go\ntype SvgExporterVisitor struct{}\n\nfunc (v *SvgExporterVisitor) VisitCircle(circle Circle) {\n\tfmt.Println(\"\")\n}\n\nfunc (v *SvgExporterVisitor) VisitRectangle(rectangle Rectangle) {\n\tfmt.Println(\"\")\n}\n```\n\n```csharp\nclass SvgExporterVisitor : IShapeVisitor\n{\n public void VisitCircle(Circle circle)\n {\n Console.WriteLine(\"\");\n }\n\n public void VisitRectangle(Rectangle rectangle)\n {\n Console.WriteLine(\"\");\n }\n}\n```\n\n```typescript\nclass SvgExporterVisitor implements ShapeVisitor {\n visitCircle(circle: Circle): void {\n console.log(\"\");\n }\n\n visitRectangle(rectangle: Rectangle): void {\n console.log(\"\");\n }\n}\n```\n\n\n### 5. Client Code\n\nNow you can operate on the shape structure using any visitor.\n\n\n```java\npublic class VisitorPatternDemo {\n public static void main(String[] args) {\n List shapes = List.of(\n new Circle(5),\n new Rectangle(10, 4),\n new Circle(2.5)\n );\n\n System.out.println(\"=== Calculating Areas ===\");\n ShapeVisitor areaCalculator = new AreaCalculatorVisitor();\n for (Shape shape : shapes) {\n shape.accept(areaCalculator);\n }\n\n System.out.println(\"\\n=== Exporting to SVG ===\");\n ShapeVisitor svgExporter = new SvgExporterVisitor();\n for (Shape shape : shapes) {\n shape.accept(svgExporter);\n }\n }\n}\n```\n\n```python\ndef main():\n shapes = [\n Circle(5),\n Rectangle(10, 4),\n Circle(2.5)\n ]\n \n print(\"=== Calculating Areas ===\")\n area_calculator = AreaCalculatorVisitor()\n for shape in shapes:\n shape.accept(area_calculator)\n \n print(\"\\n=== Exporting to SVG ===\")\n svg_exporter = SvgExporterVisitor()\n for shape in shapes:\n shape.accept(svg_exporter)\n\nif __name__ == \"__main__\":\n main()\n```\n\n```cpp\nint main() {\n Shape* shapes[] = {\n new Circle(5),\n new Rectangle(10, 4),\n new Circle(2.5)\n };\n\n printf(\"=== Calculating Areas ===\\n\");\n AreaCalculatorVisitor areaVisitor;\n for (int i = 0; i < 3; i++) {\n shapes[i]->accept(&areaVisitor);\n }\n\n printf(\"\\n=== Exporting to SVG ===\\n\");\n SvgExporterVisitor svgVisitor;\n for (int i = 0; i < 3; i++) {\n shapes[i]->accept(&svgVisitor);\n }\n\n for (int i = 0; i < 3; i++) {\n delete shapes[i];\n }\n\n return 0;\n}\n```\n\n```go\nfunc main() {\n\tshapes := []Shape{\n\t\tNewCircle(5),\n\t\tNewRectangle(10, 4),\n\t\tNewCircle(2.5),\n\t}\n\n\tfmt.Println(\"=== Calculating Areas ===\")\n\tareaCalculator := &AreaCalculatorVisitor{}\n\tfor _, shape := range shapes {\n\t\tshape.Accept(areaCalculator)\n\t}\n\n\tfmt.Println(\"\\n=== Exporting to SVG ===\")\n\tsvgExporter := &SvgExporterVisitor{}\n\tfor _, shape := range shapes {\n\t\tshape.Accept(svgExporter)\n\t}\n}\n```\n\n```csharp\npublic class Program\n{\n public static void Main(string[] args)\n {\n IShape[] shapes = {\n new Circle(5),\n new Rectangle(10, 4),\n new Circle(2.5)\n };\n\n Console.WriteLine(\"=== Calculating Areas ===\");\n IShapeVisitor areaCalculator = new AreaCalculatorVisitor();\n foreach (IShape shape in shapes)\n {\n shape.Accept(areaCalculator);\n }\n\n Console.WriteLine(\"\\n=== Exporting to SVG ===\");\n IShapeVisitor svgExporter = new SvgExporterVisitor();\n foreach (IShape shape in shapes)\n {\n shape.Accept(svgExporter);\n }\n }\n}\n```\n\n```typescript\nclass VisitorPatternDemo {\n static main(): void {\n const shapes: Shape[] = [\n new Circle(5),\n new Rectangle(10, 4),\n new Circle(2.5)\n ];\n\n console.log(\"=== Calculating Areas ===\");\n const areaCalculator: ShapeVisitor = new AreaCalculatorVisitor();\n for (const shape of shapes) {\n shape.accept(areaCalculator);\n }\n\n console.log(\"\\n=== Exporting to SVG ===\");\n const svgExporter: ShapeVisitor = new SvgExporterVisitor();\n for (const shape of shapes) {\n shape.accept(svgExporter);\n }\n }\n}\n```\n\n\n#### Expected Output:\n\n\n```shell\n=== Calculating Areas ===\nArea of Circle: 78.53981633974483\nArea of Rectangle: 40.0\nArea of Circle: 19.634954084936208\n\n=== Exporting to SVG ===\n\n\n\n```\n\n\n### What We Achieved\n\n- **Decoupled logic: **Shape classes are clean; logic lives in visitors\n- **Open/Closed Principle: **Easily add new visitors (e.g., `JsonExporterVisitor`) without touching shapes\n- **Double dispatch: **Eliminated need for `instanceof` or type-checking\n- **Reusability & maintainability: **Each visitor focuses on one operation and is testable in isolation","pageType":"lld-interviews"}

Get Premium