Visitor Design Pattern In C++

In this guide, we will explore visitor design patterns in C++ along with multiple illustrations and their benefits.

Visitor Design Pattern:

Behavioral design patterns encompass various strategies for managing object interactions, one of which is the Visitor pattern. This pattern focuses on defining a new operation without altering the classes of the elements on which it operates. By doing so, it enables the separation of algorithms from the object structure they operate on. In essence, the Visitor pattern imparts visitors with the ability to navigate and manipulate the elements within object structures based on their specific characteristics.

Important Factors of Vector Design Pattern:

The key aspects of the Visitor design pattern include the following characteristics.

Visitors:

The concept of "visitor" pertains to an abstract class or interface that outlines a set of visit procedures, with each one aligning with a distinct element within the object system.

Each specific concrete visitor embodies a distinct operation that needs to be executed using the resources at hand.

Accepted techniques are specified by an abstract base class. Once the visiting entity is recognized, this method permits the visitor to traverse and engage with the structural components of the objects.

Concrete Components:

• ✅ These represent tangible classes that match the components of the object structure.
• ✅ They employ the accept method to communicate with the visitor's corresponding visit method.

Example 1:

Let's consider a scenario to demonstrate the Visitor Design Pattern in C++.

#include<iostream>
#include<vector>
// Forward declaration of element classes
class ConcreteElementA;
class ConcreteElementB;
// Visitor interface
class Visitor {
public:
    virtual void visit(ConcreteElementA& element) = 0;
    virtual void visit(ConcreteElementB& element) = 0;
};
// Element base class
class Element {
public:
    virtual void accept(Visitor& visitor) = 0;
};
// Concrete elements
class ConcreteElementA: public Element {
public:
    void accept(Visitor& visitor) override {
        visitor.visit(*this);
    } 
    void operationA() {
        std::cout << "Operation A on ConcreteElementA" << std::endl;
    }
};
class ConcreteElementB: public Element {
public:
    void accept(Visitor& visitor) override {
        visitor.visit(*this);
    } 
    void operationB() {
        std::cout << "Operation B on ConcreteElementB" << std::endl;
    }
};
// Concrete visitor implementing specific operations
class ConcreteVisitor: public Visitor {
public:
    void visit(ConcreteElementA& element) override {
        element.operationA();
    }
    void visit(ConcreteElementB& element) override {
        element.operationB();
    }
};
int main() {
    ConcreteElementA elementA;
    ConcreteElementB elementB;
    ConcreteVisitor visitor;
    // Using the visitor to perform operations on elements
    elementA.accept(visitor);
    elementB.accept(visitor);
    return 0;
}

Output:

Explanation of Code:

• ✅ ConcreteElementA and ConcreteElementB are concrete element classes derived from the parent element.
• ✅ The accept function is implemented by any concrete element class, which accepts the Visitor object and calls the relevant visit method on it.
• ✅ Visitor Interaction: The visitor interface defines virtual visit options for each solid element.
• ✅ Concrete visitor classes use these methods to apply certain actions to each element type.
• ✅ Visitor Use: The visitor interface is implemented by the concrete visitor class ConcreteVisitor. Identifies operations to be performed on each element and provides practical applications for tourism methods.
• ✅ The visitor interface defines virtual visit options for each solid element.
• ✅ The visitor interface is implemented by the concrete visitor class ConcreteVisitor.
• ✅ Identifies operations to be performed on each element and provides practical applications for tourism methods.

Example 2:

Let's consider another instance to demonstrate the Visitor Design Pattern in C++.

#include<iostream>
#include<vector>
#include<string>
// Forward declaration of element classes
class File;
class Directory;
// Visitor interface
class Visitor {
public:
    virtual void visit(File& file) = 0;
    virtual void visit(Directory& directory) = 0;
};
// Element base class
class Element {
public:
    virtual void accept(Visitor& visitor) = 0;
};
// Concrete elements
class File: public Element {
private:
    std::string name;
public:
    File(const std:: string& name):name(name){}
    const std::string& getName() const{
        return name;
    }
    void accept(Visitor& visitor) override {
        visitor.visit(*this);
    }
};
class Directory: public Element {
private:
    std::string name;
    std::vector<Element*> children;
public:
    Directory(const std::string& name) : name(name) {}
    const std::string& getName() const {
        return name;
    }
    void addChild(Element* child) {
        children.push_back(child);
    }
    const std::vector<Element*>& getChildren() const {
        return children;
    }
    void accept(Visitor& visitor) override {
        visitor.visit(*this);
    }
};
// Concrete visitor implementing specific operations
class FileVisitor: public Visitor {
public:
    void visit(File& file) override {
	std::cout<<"File:"<<file.getName()<<std::endl;
    }
    void visit(Directory& directory) override {
       std::cout<<"Directory"<<directory.getName()<<std::endl;
        for (Element* child : directory.getChildren()) {
            child->accept(*this);
        }
    }
};
int main() {
    Directory root("Root");
    Directory dir1("Dir1");
    Directory dir2("Dir2");
    File file1("File1.txt");
    File file2("File2.cpp");
    root.addChild(&dir1);
    root.addChild(&dir2);
    dir1.addChild(&file1);
    dir2.addChild(&file2);
    FileVisitor fileVisitor;
    root.accept(fileVisitor);
    return 0;
}

Output:

Explanation of Code:

• ✅ Concrete element classes that derive from the base class Element include File and Directory.
• ✅ The accept function, which takes a Visitor object and calls the relevant visit method on it, is implemented by each specific element class.
• ✅ Visitor Interface: The Visitor interface declares virtual visit methods for every kind of visible element (File and Directory).
• ✅ Visitor Implementation: The Visitor interface is implemented by the concrete visitor class FileVisitor. It gives specific examples of how to use the visit methods and specifies what needs to be done for each kind of element.
• ✅ The Visitor interface declares virtual visit methods for every kind of visible element (File and Directory).
• ✅ The Visitor interface is implemented by the concrete visitor class FileVisitor.
• ✅ It gives specific examples of how to use the visit methods and specifies what needs to be done for each kind of element.

Advantages of the Visitor Design pattern:

The Visitor design pattern has several benefits.

• ✅ Separation of Concerns: It encourages simpler, more modular code by keeping the actions carried out on an object structure apart from the structure itself.
• ✅ Extensibility: New operations can be readily added by creating new concrete visitor classes without changing the existing code.
• ✅ Maintainability: Modifications to the object structure make it simpler to update and maintain the codebase because they do not impact the visitor classes, and vice versa.
• ✅ Double Dispatch: The pattern makes double dispatch possible, enabling the selection of the proper action depending on the kind of element as well as the type of visitor.listing code.