Question

How would I test this code thoroughly in a main.cpp file. Locomotive is an abstract base class. steam and dieselElectric are the derived classes.

#ifndef COMMODITY_H
#define COMMODITY_H
#include <iostream>
#include <string>
using namespace std;
class commodity
{
private:
   string name;
   int quantity;
public:
   commodity(commodity *c);
   commodity(string name,int quantity);
   ~commodity();
   string getName() const;
   int getQuantity() const;
};
#endif

#include "commodity.h"

commodity::commodity(commodity *c)
{       this->name=c->getName();
   this->quantity=c->getQuantity();
}

commodity::commodity(string name,int quantity)
{       this->name=name;
   this->quantity=quantity;
}

commodity::~commodity()
{cout<<getName()<<endl;}

string commodity::getName() const
{return name;}

int commodity::getQuantity() const
{return quantity;}

#ifndef REQUEST_H
#define REQUEST_H
#include "commodity.h"
class request
{
private:
      string id;
      double targetDistance;
      commodity** items;
      int numItems;
public:
      request(request *r);
      request(string id,double targetDistance,int numItems);
      ~request();
      int addItem(commodity *c);
      int addItem(string name,int quantity);
      string removeItem(int i);
      double getDistance();
      string getID();
      int getNumItems();
      commodity* getItem(int i);
};
#endif

#include"request.h"

request::request(request *r)
{   this->id=r->getID();
    this->targetDistance=r->getDistance();
    this->numItems=r->getNumItems();
    items=new commodity*[numItems];
    for(int i=0;i<numItems;i++) {this->items[i]=r->getItem(i);}
}

request::request(string id,double targetDistance,int numItems)
{   this->id=id;
    this->targetDistance=targetDistance;
    this->numItems=numItems;
    items=new commodity*[numItems];
}

request::~request()
{delete [] items;}

int request::addItem(commodity *c)
{   int i;
    for(i=0;i<this->numItems;i++)
    {   if(this->items[i]==NULL)
        {   this->items[i]=c;
            break;}
    }
    if(i==this->numItems) {return -1;}
    else {return i;}
}

int request::addItem(string name,int quantity)
{   commodity *c=new commodity(name,quantity);
    return addItem(c);
}

string request::removeItem(int i)
{   string notFound="Commodity Not Found";
    if(i<0 || i>=this->numItems) return notFound;
    commodity *c = this->items[i];
    this->items[i]=NULL;
    string name=c->getName();
    return name;
}

double request::getDistance()
{return targetDistance;}

string request::getID()
{return id;}

int request::getNumItems()
{return numItems;}

commodity* request::getItem(int i)
{if(i<0 || i>this->numItems) {return NULL;}
    return items[i];
}

#ifndef LOCOMOTIVE_H
#define LOCOMOTIVE_H
#include <iostream>
#include <string>
#include "commodity.h"
using namespace std;
class locomotive
{
private:
   string name;
   double topSpeed;
   int maxCars;
   int tonLimit;
   commodity ** cars;
public:
   locomotive();
   locomotive(string name, double topSpeed, int maxCars, int tonLimit);
   string getName();
   void setName(string s);
   const double getTopSpeed();
   const int getMaxCars();
   const int getTonLimit();
   void setTopSpeed(double s);
   void setMaxCars(int s);
   void setTonLimit(int s);
   double getCurrentTopSpeed();
   void printManifest();
   int addCar(commodity *c);
   int removeCar(string s);
   void unassignCars();
   commodity * getFirstCar();
   int getCurrentTons();
   int getCurrentCars();
   virtual ~locomotive();
   virtual string generateID()= 0;
   virtual double calculateRange();
   virtual string getType();
};

#include "locomotive.h"
locomotive::locomotive()
{}

locomotive::locomotive(string name, double topSpeed, int maxCars, int tonLimit)
{ this->name = name;
   this->topSpeed = topSpeed;
   this->maxCars = maxCars;
   this->tonLimit = tonLimit;
   this->cars = new commodity *[maxCars];
   for (int i = 0; i < maxCars; i++) {this->cars[i] = NULL;}
}

locomotive::~locomotive()
{delete [] cars;}

string locomotive::getName()
{return this->name;}

void locomotive::setName(string s)
{name = s;}

double locomotive::getTopSpeed() const
{return topSpeed;}

int locomotive::getMaxCars() const
{return maxCars;}

int locomotive::getTonLimit() const
{return tonLimit;}

void locomotive::setTonLimit(int s)
{tonLimit = s;}

void locomotive::setTopSpeed(double s)
{topSpeed = s;}

void locomotive::setMaxCars(int s)
{ this->maxCars = s;
   if (this->cars == NULL)
   {   this->cars = new commodity *[maxCars];
       for (int i = 0; i < maxCars; i++) {this->cars[i] = NULL;}
   }
}

int locomotive::getCurrentTons()
{ int total_ton=0;
   for (int i = 0; i < this->maxCars; i++)
   {if (this->cars[i] != NULL) {total_ton += this->cars[i]->getQuantity();}}
   return total_ton;
}

int locomotive::getCurrentCars()
{ int total_car = 0;
   for (int i = 0; i < this->maxCars; i++)
   {   if (this->cars[i] != NULL)
       {total_car ++;}
   }
   return total_car;
}

commodity *locomotive :: getFirstCar()
{ for (int i = 0; i < this->maxCars; i++)
   {   if (this->cars[i] != NULL)
       {return this->cars[i];}
   }
   return NULL;
}
double locomotive::calculateRange()
{return 0.0;}
int locomotive::addCar(commodity *c)
{ int i;
   if (getCurrentTons() + c->getQuantity() > getTonLimit()) {return -1;}
       for (i = 0; i < this->maxCars; i++)
       {   if (this->cars[i] == NULL)
           {   this->cars[i] = c;
               break;
           }
       }
       if (i == this->maxCars) {return -1;}
       return i;
}

int locomotive::removeCar(string s)
{ int flag = -1;
   for (int i = 0; i < this->maxCars; i++)
   {   if (this->cars[i] != NULL)
       {   if (this->cars[i]->getName() == s)
           {   commodity * tmp = this->cars[i];
               this->cars[i] = NULL;
               flag = i;
               break;
           }
       }
   }
   return flag;
}

void locomotive::unassignCars()
{
   for (int i = 0; i < this->maxCars; i++)
   {
       if (this->cars[i] != NULL)
       {       commodity * tmp = this->cars[i];
               this->cars[i] = NULL;
}}}

void locomotive:: printManifest()
{ int count=1;
   cout << "Train: " << this->name << endl;
   for (int i = 0; i < this->maxCars; i++)
   {   if (this->cars[i] != NULL)
       {   cout << "Car " << count << ": " << this->cars[i]->getName() << endl;
       count++;
       }}
   cout << "Total Tons: " << getCurrentTons() << endl;
}

double locomotive::getCurrentTopSpeed()
{ double current_speed = (getTopSpeed() - (1.7*getCurrentCars() - (1.01*(getCurrentTons() / 10.0))));
   if (getCurrentTons() > getTonLimit() || current_speed < 0) {return 0.0;}
   return current_speed;
}

string locomotive::getType()
{return "";}

#ifndef DIESELELECTRIC_H
#define DIESELELECTRIC_H
#include "locomotive.h"
#include <sstream>
using namespace std;
class dieselElectric : public locomotive
{
private:
    int fuelSupply;
public:
    int getSupply();
    void setSupply( int s);
    dieselElectric(int f);
    ~dieselElectric();
    string generateID();
    double calculateRange();
    string getType();
};
#endif

#include "dieselElectric.h"
#include<iostream>
#include<string>

int dieselElectric::getSupply()
{return fuelSupply;}

void dieselElectric::setSupply(int s)
{fuelSupply = s;}

dieselElectric::dieselElectric(int f)
{fuelSupply = f;}

dieselElectric::~dieselElectric()
{ cout<<"Diesel Electric Train: "<<this->getName()<<endl;}

string dieselElectric::generateID()
{   string id = getType()+"-";
    commodity *first = getFirstCar();
    if(first->getName().length() <= 3) {id += first->getName();}
    else {id += first->getName().substr(0,3);}
    stringstream ss;
    ss << getCurrentTons();
    string tonnage;
    ss >> tonnage;
    id += "-"+tonnage;
    return id;
}

double dieselElectric::calculateRange()
{   double range = 0.0;
    range = this->fuelSupply*3.5;
    range = range - (5*(this->getCurrentTons()/this->getCurrentCars()));
    if(range < 0) {range = 0;}
    return range;
}

string dieselElectric::getType()
{return "dieselElectric";}

#ifndef STEAM_H
#define STEAM_H
#include "locomotive.h"
#include <sstream>
using namespace std;
class steam : public locomotive
{
private:
   int coal;
   int water;
public:
   int getWater();
   void setWater(int s);
   int getCoal();
   void setCoal(int s);
   steam(int c, int w);
   ~steam();
   string generateID();
   double calculateRange();
   string getType();
};
#endif

#include "steam.h"

int steam::getWater()
{return water;}

void steam::setWater(int s)
{water = s;}

int steam::getCoal()
{return coal;}

void steam::setCoal(int s)
{coal = s;}

steam::steam(int c, int w)
{ coal = c;
water = w;
}

steam::~steam()
{cout<<"Steam Train: "<<this->getName()<<endl;}

string steam::generateID()
{   string id = getType()+"-";
    commodity *first = getFirstCar();
    if(first->getName().length() <= 3) {id += first->getName();}
    else {id += first->getName().substr(0,3);}
    stringstream ss;
    ss << getCurrentTons();
    string tonnage;
    ss >> tonnage;
    id += "-"+tonnage;
    return id;
}

double steam::calculateRange()
{   int baseRange ;
    if((coal%water) == 0)
    {
        if((coal/water) == 2) {baseRange = coal;}
        else {baseRange = 0;}
    }
    else {baseRange = 0;}
    double range = ((double)baseRange) - 1.2*getCurrentCars();
    if(range < 0)
        {range = 0;}
    return range;
}

string steam::getType()
{return "steam";}

Answer 1

In main.cpp

Create some objects of Commudity.

Create DieselElectric class objects and Steam class objects, and point the objects via Locomotive object pointer as shown below.

Locomotive* l1 = new electricDiesel();

Locomotive* l2 = new steam();

Here, locomotive will act as an interface.

Call the methods and check the functionality