Derived clases and polymorphism - adhoc-polymorphism

Question

The given code for my program is:
class Hive
{
private:
Bee* queen;
Bee* worker;
Bee* drone;
public:
Hive();
void activity();
~Hive();
};
Coding instructions have been provided and I must add the code. My constructor as coded, has the following error:"Cannot allocate an object of abstract type"
Hive::Hive() //This is where my error is
{
//Create an instance of each derived class
queen = new Queen(1,1) ;
worker = new Worker(1,1) ;
drone = new Drone(1,1) ;
}
void Hive::activity()
{
//Polymorphically call each classes work function
queen->Work() ;
worker->Work() ;
drone->Work() ;
}
Hive::~Hive()
{
//Deal with dynamic memory
delete queen ;
delete worker ;
delete drone ;
}
My derived class definitions are:
class Drone : Bee /*Indicate that a Drone IS A Bee*/
{
private:
char fertile;
public:
Drone(int lifespan, char fertile);
virtual void work();
};
class Queen : Bee /*indicate that a Queen IS A Bee*/
{
private:
int numBabies;
public:
Queen(int lifespan, int numBabies);
virtual void work();
};
class Worker : Bee /*Indicate that a Worker IS A Bee*/
{
private:
int honeyMade;
public:
Worker(int lifespan, int honeyMade);
virtual void work();
};
Hopefully I didn't make additional mistakes.

Answer 1

The main:
include <iostream>
include "Hive.h"
using namespace std;
using namespace HiveSpace;
int main()
{
Hive h;
h.activity();
return 0;
}
Classes
#ifndef HIVE_H
#define HIVE_H
#include "Bee.h"
#include "Queen.h"
#include "Drone.h"
#include "Worker.h"
namespace HiveSpace
{
class Hive
{
private:
Bee* queen;
Bee* worker;
Bee* drone;
public:
Hive();
void activity();
~Hive();
};
}
#endif
///
#include "Hive.h"
#include <iostream>
using namespace std;
namespace HiveSpace
{
Hive::Hive()
{
//Create an instance of each derived class
queen = new Queen(1,1) ;
worker = new Worker(1,1) ;
drone = new Drone(1,1) ;
}
void Hive::activity()
{
//Polymorphically call each classes work function
queen->Work() ;
worker->Work() ;
drone->Work() ;
}
Hive::~Hive()
{
//Deal with dynamic memory
delete queen ;
delete worker ;
delete drone ;
}
}
///
#ifndef BEE_H
#define BEE_H
namespace HiveSpace
{
class Bee
{
private:
int lifespan;
public:
Bee(int lifespan);
//Add pure virtual function for work
virtual void Work() = 0 ;
//Create polymorphic destructor
virtual ~Bee() ; // ADDED
};
}
#endif
/////
#include "Bee.h"
#include <iostream>
using namespace std;
namespace HiveSpace
{
void Bee::Work()
{
//Nothing to do here
}
Bee::Bee(int lifespan)
{
cout << "Constructor for Bee base class " << endl;
this->lifespan = lifespan;
}
Bee::~Bee()
{
//Nothing special to do here
cout << "Destructor for Bee base class << endl;
}
}
///
#ifndef DRONE_H
#define DRONE_H
#include "Bee.h"
namespace HiveSpace
{
class Drone : Bee /*Indicate that a Drone IS A Bee*/
{
private:
char fertile;
public:
Drone(int lifespan, char fertile);
virtual void work();
};
}
#endif
///
#include "Drone.h"
#include <iostream>
using namespace std;
namespace HiveSpace
{
//Provide a constructor which also invokes the base class constructor
Drone::Drone(int lifespan, char fertile) : Bee(lifespan)
{
// this->fertile = fertile ;
}
void Drone::work()
{
cout << "Drone derived class working " << endl;
}
}
#ifndef QUEEN_H
#define QUEEN_H
#include "Bee.h"
namespace HiveSpace
{
class Queen : Bee /*indicate that a Queen IS A Bee*/
{
private:
int numBabies;
public:
Queen(int lifespan, int numBabies);
virtual void work();
};
}
#endif
///
#include "Queen.h"
#include <iostream>
using namespace std;
namespace HiveSpace
{
//Provide a constructor which also invokes the base class constructor
Queen::Queen(int lifespan, int numBabies) : Bee(lifespan)
{
this->numBabies = numBabies ;
}
void Queen::work()
{
cout << "Queen derived class working"<< endl;
numBabies++;
}
}
////
#ifndef WORKER_H
#define WORKER_H
#include "Bee.h"
namespace HiveSpace
{
class Worker : Bee /*Indicate that a Worker IS A Bee*/
{
private:
int honeyMade;
public:
Worker(int lifespan, int honeyMade);
virtual void work();
};
}
#endif
///
#include "Worker.h"
#include <iostream>
using namespace std;
namespace HiveSpace
{
//Provide a constructor which also invokes the base class constructor
Worker::Worker(int lifespan, int honeyMade) : Bee(lifespan)
{
this->honeyMade = honeyMade ;
}
void Worker::work()
{
cout << "Worker derived class working" << endl;
honeyMade++;
}
}