Походные clases и полиморфизм

Question

Данный код моей программы: были предоставлены

class Hive 
{ 
    private: 
     Bee* queen; 
     Bee* worker; 
     Bee* drone; 

    public: 
     Hive(); 
     void activity(); 
     ~Hive(); 
}; 

инструкции по кодированию, и я должен добавить код. Мой конструктор, как кодируются, имеет следующую ошибку: «Не удается выделить объект абстрактного типа»

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 ; 
} 

Мои полученные определения класса являются:

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(); 
}; 

Надеюсь, я не делал дополнительных ошибок.

Answer 1

Основные:

include <iostream> 
include "Hive.h" 

using namespace std; 

using namespace HiveSpace; 

int main() 
{ 
Hive h; 
h.activity(); 
return 0; 
} 

Классы

#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++; 
} 
}