What is visitor pattern?
1. It encapsulates an operation executed on an
object hierarchy in an object. That says, it allows to add methods to classes
of different types without much altering to those classes.
2.
Enables to define new operations without
changing the object hierarchy.
Use-Case:
a. Operations shall be performed on
object hierarchy
b. The operations change frequently
but object hierarchy is stable.
Basic UML Class Diagram:
Visitor:
· Defines the visit operation on the object
structure
Tax Visitor:
· Implements the visit operation for each type of
object
Visitable:
· Defines the accept operation which takes visitor
as an argument
Visitable
Element(s):
· Implements
accept operations
The Visitor pattern has two types of hierarchies. The object hierarchy (Visitable elements) and the operation hierarchy (TaxVisitor). The object hierarchy is pretty stable, but operation hierarchy may support different operations on same object hierarchy. In our case Visitor and Visitable acts as interfaces. What does it mean? It means Liquor, Tobacco and Necessity must implement accept member function. Similarly, TaxVisitor must implement overloads of visit function for each object type.
Operation wise, TaxVisitor is applied to object hierarchy. The job of TaxVisitor is to calculate tax based on object type visited. The crucial observation here is an object e.g., Liquor accepts the visitor and uses the visitor to call back the operation hierarchy (visit.visit(*this)), using self as an argument.
Let’s explore the code:
File: Visitor.h
/*Visitor Interface*/
#pragma once
class Liquor;
class Tobacco;
class Necessity;
class Visitor
{
public:
virtual double visit(Liquor liquorItem) = 0;
virtual double visit(Tobacco tobaccoItem) = 0;
virtual double visit(Necessity necessityItem) = 0;
};
File: TaxVisitor.h
/* Tax Visitor */
#pragma once
#include "Visitor.h"
#include "Liquor.h"
#include "Tobacco.h"
#include "Necessity.h"
#include <fmt/format.h>
class TaxVisitor : public Visitor{
public:
TaxVisitor(){}
public:
double visit (Liquor liquorItem){
fmt::print("This is liquor tax\n");
return ((liquorItem.getPrice() * 0.18) +
liquorItem.getPrice());
}
double visit (Tobacco tobaccoItem){
fmt::print("This is tobacco tax\n");
return ((tobaccoItem.getPrice() * 0.28) +
tobaccoItem.getPrice());
}
double visit (Necessity necessityItem){
fmt::print("This is necessity tax\n");
return ((necessityItem.getPrice() * 0) +
necessityItem.getPrice());
}
};
File: Visitable.h
/* Visitable */
#pragma once
#include "Visitor.h"
class Visitable
{
public:
virtual double accept(Visitor& visit) = 0;
};
File: Liquor.h
/* Liquor.h */
#pragma once
#include "Visitable.h"
class Liquor :
public Visitable
{
private:
double price;
public:
// CTOR...
Liquor(double item) {
price = item;
}
double getPrice() {
return price;
}
double accept(Visitor& visit)
{
return visit.visit(*this);
}
};
File: Tobacco.h
/* Tobacco.h */
#pragma once
#include "Visitable.h"
class Tobacco :
public Visitable
{
private:
double price;
public:
// CTOR...
Tobacco(double item) {
price = item;
}
double getPrice() {
return price;
}
double accept(Visitor& visit)
{
return visit.visit(*this);
}
};
File: Necessity.h
/* Necessity.h */
#pragma once
#include "Visitable.h"
class Necessity :
public Visitable
{
private:
double price;
public:
// CTOR...
Necessity(double item) {
price = item;
}
double getPrice() {
return price;
}
double accept(Visitor& visit)
{
return visit.visit(*this);
}
};
File: example.cpp
#include "TaxVisitor.h"
int main() {
TaxVisitor taxCalc;
Necessity milk(3.47);
fmt::print("{}\n", milk.accept(taxCalc));
Liquor wine(11.20);
fmt::print("{}\n", wine.accept(taxCalc));
Tobacco cig(19.89);
fmt::print("{}\n", cig.accept(taxCalc));
return 0;
}
(This is same demo code on compiler explorer)
Credit: Design Patterns: Elements of Reusable Object-Oriented Software (By GoF),
Rainer Grimm & Derek Banas
Comments