Dynamic Allocation

CS177/457 C++ Programming
Spring 1998
Feeding time: Dynamic allocation and virtual functions

Introduction

Your program will print out a feeding schedule for all the animals in the zoo. Different kinds of animals have different feeding requirements--type of food, amount of food and how it is to be delivered.

Requirements

There are three kinds of animals in our zoo: mammals, reptiles and birds. In the mammals, we have two tigers, Kuma, and Aralta; a donkey, Phil, and a panda LimLim. Amongst the reptiles we have an anaconda called Fred, two iguanas, Charles and Diana, and a crocodile called Sugar. The birds don't have names, but numbers: six lesser crested thrushes, numbers 4725 through 4730, a horn-billed parrot, number 2122, and ten north American starlings, numbers 3010 through 3019. It's a small zoo!

The feeding requirements are in the table below:

Animal	Type of food	Amount	Delivery
tiger	beef	10 pounds	remote
donkey	hay	5 pounds	pen
panda	bamboo leaves	20 pounds	remote
anaconda	live rat	1	cage
iguana	crickets	25	cage
crocodile	dead rat	6	remote
thrush	seeds	2 ounces	pen
parrot	seeds	4 ounces	hand
starling	live bugs	1 ounce	cage

Your program should be able to add new animals, store the information in a database and print feeding requirements of all the animals in the zoo.

Hints and notes

The crucial question to answer is how these animals are to be represented and stored in a database. Use a vector of pointers to Animal to do this:

class Animal { … };
vector<Animal*> zoo;

This will enable you to derive classes for the different types of animal from Animal and then use virtual functions to print the the feeding requirements.

for (int animal = 0; animal < zoo.size(); animal++)
zoo[animal]->printFeedingRequirements();

The next question is are all the different animals to be represented as derived from Animal or is there a set of intermediate classes that can make my functions more efficent? Add an intermediate layer, organized any way you wish, so that e.g. Donkey is derived from PlantEating which is derived from Animal. Or it might be that Donkey is derived from FedInPen which is derived from Animal.

Whichever way you define the intermediate layer, there will be separate (derived) classes for each of the kinds of animal, each will have a printFeedingReuqirements function that will be different. Depening on how your hierarchy works, you can call the same function from the superclass to print out part of the requirements.

Add the animals to the database vector using the new operator. e.g.

zoo.push_back(new Donkey("Phil"));
zoo.push_back(new Anaconda("Fred"));

Deliverables

Source code showing classes for Animal, each of the kinds listed in the table, and several in an intermediate layer. Each class has one public function (apart from its constructor): printFeedingRequirements, which MUST be virtual in class Animal. The main function makes the zoo, adds the animals and feeds them:

int main() {
vector<Animal*> zoo;

zoo.push_back(new Donkey("Phil"));
zoo.push_back(new Anaconda("Fred"));
…
for (int animal = 0; animal < zoo.size(); animal++)
zoo[animal]->printFeedingRequirements();
}

Output that states the feeding requiremens for each animal in the zoo.

Due Date

Friday 24^th. April at 5 pm.