Project 1: OOP and Inheritance Solution

Aim: The aim of this project is to reinforce the concept of OOP and inheritance. There are two parts that need to be completed.

Part 1:

Write a class: Animal. Every Animal has a name, it may be domestic (or not) and it may be a predator (or not).

Part 2:

Write the following 3 classes that derive from Animal but also have other attributes specific to their type:

    • Mammal

    • Bird

    • Fish

Implementation:

You must separate interface from implementation (both .hpp and .cpp files for each class) and implement the class based on the following specification. Function prototypes and member variable names must match exactly.

The Animal class has only accessor and mutator functions for its private data members. Recall that accessor functions (e.g. getName()) are used to access the private data members (e.g. all getName() will do is return name_), while mutator functions give a value to the data members.

As you implement the three classes for part 2, think about what is inherited and what is not (e.g. constructors are not inherited!!!). Also think about the order in which constructors are called, and how/where must you explicitly call the base class constructor. Constructors must initialize data members to 0 or false unless an argument is passed for that data member. You must write Animal to support inheritance and provide direct access from the derived classes to its private members.

Remember, you must thoroughly document your code!!!
*********************

class Animal public members:
Animal();

Animal(std::string name, bool domestic = false, bool predator = false);

std::string getName() const;

bool isDomestic() const;

bool isPredator() const;

void setName(std::string name);

void setDomestic();

void setPredator();

class Animal private members:

std::string name_;

bool domestic_;

bool predator_;



*********************

class Mammal public members:
Mammal();

Mammal(std::string name, bool domestic = false, bool predator = false); bool hasHair() const;

bool isAirborne() const;

bool isAquatic() const;

bool isToothed() const;

bool hasFins() const;

bool hasTail() const;

int legs() const;

void setHair();

void setAirborne();

void setAquatic();

void setToothed();

void setFins();

void setTail();

void setLegs(int legs);


class Mammal private members:

bool hair_;

bool airborne_;

bool aquatic_;

bool toothed_;

bool fins_;

bool tail_;

int legs_;




class Bird public members:


Bird();

Bird(std::string name, bool domestic = false, bool predator = false); bool isAirborne() const;

bool isAquatic() const;

void setAirborne();


void setAquatic();


class Bird private members:


bool airborne_;

bool aquatic_;


_____________________________________________________________________________


class Fish public members:

Fish();

Fish( std::string name, bool domestic = false, bool predator = false); bool isVenomous() const;

void setVenomous();

class Fish private members:


bool venomous_;

*********************

Testing:


You must always implement and test your programs INCREMENTALLY!!!

What does this mean?

    • Implement and test one class at a time!!!

    • For each class:

        ◦ Implement one function/method and test it thoroughly (multiple test cases + edge cases if applicable)
        ◦ Implement the next function/method and test it …



How do you do this?

Write your own main() function to test your classes. In this course you will never submit your test program but you must always write one to test your classes. As you implement each Animal method, instantiate objects of type Animal in main and call the method to test it is correct. Start from the constructor(s), then move on to the other functions. You may output the return values to inspect your program’s behavior. Choose the order in which you implement your methods so that you can test incrementally (i.e. implement mutator functions before accessor functions). Sometimes functions depend on one another. If you need to use a function you have not yet implemented, you can use stubs: a dummy implementation that always returns a single
value for testing (don’t forget to go back and implement the stub!!! If you put the word STUB in a comment, some editors will make it more visible so you will remember to implement it later)

For example:

//******** STUB ************//


bool Animal::isPredator() const

{

return false;

}


Note: this will make much more sense as your programs become more complex, but it is very important to understand the fundamental concepts and develop good implement/test/debug habits from the very beginning.

Once you are done with the Mammal class, you can move on to implementing Bird, then Fish.

In your main function you also want to test for inheritance. Think about:

    • Can you access members of the base class from the derived class? Test it!!!

    • Test calling a member function of the base class via an object to type derived. Make sure it works!

Grading Rubric:

    • Correctness 80% (distributed across unit testing of your submission)

        ◦ A submission that implements all required classes and/or functions but does not compile will receive 40 points total (including documentation and design).

    • Documentation 10%

    • Style and Design 10% (proper naming, modularity and organization)


Submission:


You will submit the following files:

    • The Animal class (Animal.hpp and Animal.cpp)

    • The Mammal class (Mammal.hpp and Mammal.cpp)

    • The Bird class (Bird.hpp and Bird.cpp)

    • The Fish class (Fish.hpp and Fish.cpp)



Your project must be submitted on Gradescope.

Although Gradescope allows multiple submissions, it is not a platform for testing and/or debugging and it should not be used for that. You MUST test and debug your program locally. Before submitting to Gradescope you MUST ensure that your program compiles (with g++) and runs correctly on the Linux machines in the labs at Hunter (see detailed instructions on how to upload, compile and run your files in the “Programming Rules” document). That is your baseline, if it runs correctly there it will run correctly on Gradescope, and if it does not, you will have the necessary feedback (compiler error messages, debugger or program output) to guide you in debugging, which you don’t have through Gradescope. “But it ran on my machine!” is not a valid argument for a submission that does not compile.

Once you have done all the above you submit it to Gradescope.

The due date is Tuesday February 18 by 5pm. No late submissions will be accepted.