Question

Consider the class hierarchy on the last page of this assignment. It is a class hierarchy of food products, including FreshVegetable and CannedItem.

A Package is also a product and is a container of multiple products.

• We wish to use the visitor pattern to implement two operations on the product hierarchy.

• The first operation is to find the cheapest item in a product, which we implement using the CheapestVisitor.

• The second operation is to reduce the price of CannedItem and FreshVegetable items in a product by specified amounts.

We implement this using the ReducePriceVisitor.

You are provided with the main program main.cpp and the completed header file for the Product hierarchy.

Note that the Package is implemented using the vector class from the c++ stl library.

The ProductVisitor hierarchy is partially implemented in ProductVisitor.h.

You need to complete the implementation of the CheapestVisitor and ReducePriceVisitor classes.

You are also required to implement the following methods in the file called ProductVisitor.cpp:

1. void ProductVisitor::visit(Package *p)

2. void CheapestVisitor::visit(FreshVegetable *p)

3. void ReducePriceVisitor::visit(FreshVegetable *p)

4. void ReducePriceVisitor::visit(CannedItem *p)

5. double CheapestVisitor::getMinPrice() // return the price of the cheapest item

6. Item *CheapestVisitor::getMinItem() // return a pointer to the cheapest item

7. void CheapestVisitor::reset() // reset the CheapestVisitor before finding another cheapest item

• All points where implementation is required are marked by the comment TO BE COMPLETED

• Compile the code using cc -o product.exe main.cpp ProductVisitor.cpp

• There are two test functions in main.cpp - change main() to try each one.

Answer 1

main.cpp

#include "Product.h"
#include "ProductVisitor.h"

#include <iostream>
using namespace std;

int main()
{
// Declare a couple of fresh vegetables and
// a canned item, giving their name and their price.

FreshVegetable carrot("carrot", 50.0), peas("peas", 60.0), parsnips("parsnips", 55.0);
CannedItem mushyPeas("mushyPeas", 80.0), bakedbeans("bakedBeans", 100.0);


// Declare some packages that can contain multiple products

Package pack1, pack2;

// Add products to the packages - pack2 contains pack1

pack1.addProduct(&carrot);
pack1.addProduct(&peas);
pack1.addProduct(&mushyPeas);

pack2.addProduct(&pack1);
pack2.addProduct(&bakedbeans);
pack2.addProduct(&parsnips);

// The Cheapest Visitor calculates the price of the cheapest
// item in the package

CheapestVisitor cheap;
pack2.accept(&cheap);
cout << "The cheapest item is "
       << cheap.getMinItem()->getName() << " at price "
       << cheap.getMinPrice() << " rupies." << endl;

ReducePriceVisitor priceModifier(0.90,0.50);
pack2.accept(&priceModifier);

// Use CheapestVisitor to re-calculate price of cheapest item

cheap.reset();       // re-set to compute a new minimum price
pack2.accept(&cheap);
cout << "The cheapest product is "
       << cheap.getMinItem()->getName() << " at price "
       << cheap.getMinPrice() << " rupies." << endl;

return 0;
}

Product.h

#ifndef _PRODUCT_H
#define _PRODUCT_H
#include <iostream>
#include <vector>
#include <cstring>
using namespace std;

const int MAX_NAME_LEN = 200;

class ProductVisitor;

class Product
{
public:
Product() {};
virtual void accept(ProductVisitor *v) = 0;
virtual double getPrice() = 0;
private:
double price;

};

class Item : public Product
{
public:
Item(const char *n) : price(0.0) {strcpy(name, n);};
Item(const char *n, double p) : price(p) {strcpy(name, n);};
virtual void accept(ProductVisitor *v) = 0;
double getPrice() {return price;};
void setPrice(double p) { price = p;};
char *getName() {return name;};

private:
double price;
char name[MAX_NAME_LEN];
};

class FreshVegetable : public Item
{
public:
FreshVegetable(const char *n) : Item(n) {};
FreshVegetable(const char *n, double p) : Item(n,p) {};

void accept(ProductVisitor *v);
};

class CannedItem : public Item
{
public:
CannedItem(const char *n) : Item(n) {};
CannedItem(const char *n, double p) : Item(n,p) {};
void accept(ProductVisitor *v);
};

class Package : public Product
{
public:
Package() {};
Package& addProduct(Product *product) { contents.push_back(product); return *this; };
Product *getProduct(int i) { return contents[i];};
int size() {return contents.size();};
virtual void accept(ProductVisitor *v);
double getPrice() { double p=0.0; for (int i=0;i<contents.size();i++) { p+=contents[i]->getPrice();} return p;};
private:
vector<Product *> contents;
};

#endif
  

  
ProductVisitor.cpp

#include "ProductVisitor.h"
#include "Product.h"

void FreshVegetable::accept(ProductVisitor *v)
{
v->visit(this);
};

void CannedItem::accept(ProductVisitor *v)
{
v->visit(this);
};

void Package::accept(ProductVisitor *v)
{
v->visit(this);
};

// Visit method for ProductVisitor class on Package class
void ProductVisitor::visit(Package *p)
{
for (int i = 0; i < p->size(); i++)
{
    p->getProduct(i)->accept(this);
}
}

// Sets the min item.
void CheapestVisitor::setMinItem(Item *p) {
if (currentMinPrice == -1) {
    this->currentMinPrice = p->getPrice();
    this->minItem = p;
} else if (p->getPrice() < currentMinPrice) {
    this->currentMinPrice = p->getPrice();
    this->minItem = p;
}
}

// Visit Method for the CheapestVisitor class on CannedItem class
void CheapestVisitor::visit(CannedItem *p)
{
this->setMinItem(p);
}

// Visit Method for the CheapestVisitor class on FreshVegetable class
void CheapestVisitor::visit(FreshVegetable *p)
{
   this->setMinItem(p);
}

ReducePriceVisitor::ReducePriceVisitor(double a, double b) {
   this->pFreshVeg = a;
   this->pCanned = b;
}

//reduce price
void ReducePriceVisitor::reducePrice(Item *p,double percentage) {
   p->setPrice((p->getPrice())*percentage);
}
// Visit Method for ReducePriceVisitor class on FreshVegetable class

void ReducePriceVisitor::visit(FreshVegetable *p)
{
   this->reducePrice(p,this->pFreshVeg);
}

// Visit Method for ReducePriceVisitor class on CannedItem class

void ReducePriceVisitor::visit(CannedItem *p)
{
   this->reducePrice(p,this->pCanned);
}

// CheapestVisitor Method to return the price of the cheapest item
double CheapestVisitor::getMinPrice()
{
return this->currentMinPrice;
}

// CheapestVisitor Method to return the cheapest Item
// If more than one item is equally cheap,
// this returns the first item which was cheap.
Item *CheapestVisitor::getMinItem()
{
return this->minItem;
}

// CheapestVisitor Method to reset before finding the minimum item

void CheapestVisitor::reset()
{
this->currentMinPrice = -1;
};

ProductVisitor.h

#ifndef _PRODUCT_VISITOR_H
#define _PRODUCT_VISITOR_H

class Product;
class Item;
class CannedItem;
class FreshVegetable;
class Package;

class ProductVisitor
{
public:
ProductVisitor() {};
virtual void visit(FreshVegetable *p)= 0;
virtual void visit(CannedItem *p) = 0;
void visit(Package *p);
};

class CheapestVisitor : public ProductVisitor
{
public:
double getMinPrice();
Item *getMinItem();
void reset();
void visit(FreshVegetable *p);
void visit(CannedItem *p);
void setMinItem(Item *p);
private:
   double currentMinPrice = -1;
   Item *minItem;

};

class ReducePriceVisitor : public ProductVisitor
{
public:
ReducePriceVisitor(double a, double b);
void visit(FreshVegetable *p);
void visit(CannedItem *p);
void reducePrice(Item *p,double percetage);
private:
   double pFreshVeg;
   double pCanned;
};
#endif