Question

Please submit the following files for this assignment:

*****************Animal.h, Animal.cpp, Mammal.h, Mammal.cpp, Cat.h, Cat.cpp, main.cpp*********

Assignment 4 – OOP – inheritances

1. Create a base class Animal (Animal.h, Animal.cpp)

Member variables (private):

string name;

string type;

Member methods (public):

Constructor(s)

Setters

Getters

eat(); //display “Eat food.”

2. Create a derived class Mammal from Animal (public) (Mammal.h, Mammal.cpp)

Member variables (private):

string hair_type; //eg: fur, hair,etc

Member methods (public):

Constructor(s)

Setters

Getters

3. Create a derived class Cat from Mammal (public) (Cat.h, Cat.cpp)

Member variables:

bool domesticated (private):

Member methods (public):

Constructor(s)

Setters

Getters

4. main()(Main.h)

Instantiate a Cat object.

Set the following values to each of the member variables

• name: “Abyssinian cat”
• type: “carnivorous mammal”
• hair_type: “short hair”
• domesticated: true
• eat () //display “Eat fish”

                                      //function overriding

Study Guide:

You may use the following class demo code as your reference.

// OOP Inheritance demo 2/28/20
#include
#include

class Animal {
private:
int legs;

public:
Animal() { legs = 0; } //default constructor
Animal(int m_legs) {legs = m_legs;} //parameterized constructor
void run() { std::cout << "Animal can run.\n";}
void setLegs(int i) {legs = i;} //setter, mutator
int getLegs() const {return legs;} //getter, accessor
//const here guarantees that the logic state of your object will not change
//Comparing: const int getLegs(); //const here means the return type is a const int
};

class Cat : public Animal {//is-a
int size;
public:
Cat(int m_size,int m_legs):Animal(m_legs) {size = m_size; } //parameterized constructor
int getSize() { return size;}
void run() { std::cout<<"Cat can run.\n"; } //function overriding. Same function signature than the one in the base class
};

int main()
{
Cat myCat(20,4);
std::cout << myCat.getSize() << "\n"
<< myCat.getLegs() << "\n";

myCat.run();
  
return 0;
  
}

Key point:

Animal(int m_legs) {legs = m_legs;} //parameterized constructor in the base class Animal

Cat(int m_size,int m_legs):Animal(m_legs) {size = m_size; } //parameterized constructor in the derived class Cat

please use Microsoft Visual Studio

C++

Answer 1

Animal.cpp

#include "Animal.h"

#include <string>

#include<iostream>

Animal::Animal(int age, std::string name) : _name(name), _age(age) { }

Animal::~Animal() { }

void Animal::sleep(){ printf("Shhh! %s is sleeping...\n", this->name); }

// Operator overloading

bool Animal::operator==(const Animal &animal){

return (this->age == animal.age()) && (this->name == animal.name());

}

std::ostream &operator<<(std::ostream &o, const Animal &animal){

return o << "Name: " << animal.name() << " Age: " << animal.age();

}

Animal.h

#include <string>

class Animal

{

private:

int _age;

std::string _name;

public:

Animal(int age, std::string name);

~Animal();

void sleep();

int age(void) const { return _age; }

std::string name() const { return _name; }

bool operator==(const Animal &animal); // the other animal is referenced by "this"

friend std::ostream &operator<<(std::ostream &o, const Animal &animal);

};

Cat.cpp

#include "Cat.h"

#include <string>

#include <iostream>

Cat::Cat(int age, std::string name, int weight) : Animal::Animal(age, name), _weight(weight) {}

Cat::~Cat()

{

}

void Cat::climb(){

std::cout << this->name() + " is climbing...";

}

std::ostream &operator<<(std::ostream &o, const Cat cat){

o << (Animal&)cat << " Weight: " << cat.weight();

return o;

}

bool Cat::operator==(const Cat &cat){

return (Animal)*this == (Animal)cat && this->weight() == cat.weight();

}

Cat.h

#include "Animal.h"

#include <string>

class Cat : public Animal

{

private:

int _weight;

public:

Cat(int age, std::string name, int weight);

~Cat();

int weight() const { return _weight; }

void climb();

bool operator==(const Cat &cat);

friend std::ostream &operator<<(std::ostream &o, const Cat &cat);

};

Dog.cpp

#include "Dog.h"

#include <iostream>

#include <string>

Dog::Dog(int age, std::string name, int numLifes) : Animal::Animal(age, name), _numLifes(numLifes) {}

Dog::~Dog() {};

void Dog::bark()

{ std::cout << ((Animal*)this)->name() + " says: \"ruff, ruff!\""; }

bool Dog::operator==(const Dog &dog){

return (Animal)*this == (Animal)dog && this->numLifes() == dog.numLifes();

}

std::ostream& operator<<(std::ostream &o, const Dog &dog){

o << (Animal)dog << " Number Of Lifes: " << dog.numLifes();

}

Dog.h

#include "Animal.h"

#include <string>

#include <iostream>

class Dog : public Animal{

private:

int _numLifes;

public:

Dog(int age, std::string name, int numLifes);

~Dog();

void bark();

int numLifes() const { return _numLifes; }

bool operator==(const Dog &dog);

friend std::ostream& operator==(std::ofstream& o, const Dog &dog);

};