Virtual functions in C++ - Mini Project: Build & Apply

Understanding Virtual Functions in C++

📖 Scenario: Imagine you are creating a simple program to manage different types of animals and their sounds. Each animal can make a sound, but the exact sound depends on the animal type.

🎯 Goal: You will build a small C++ program using classes and virtual functions to show how different animals make different sounds when called through a base class pointer.

📋 What You'll Learn

Create a base class called Animal with a virtual function makeSound().

Create two derived classes called Dog and Cat that override the makeSound() function.

Use a pointer of type Animal* to call the makeSound() function on objects of Dog and Cat.

Print the sounds made by the animals to the console.

💡 Why This Matters

🌍 Real World

Virtual functions are used in software where different objects share a common interface but have different behaviors, like in games, simulations, or user interface toolkits.

💼 Career

Understanding virtual functions is essential for C++ developers working on object-oriented design, enabling flexible and maintainable code.

1

Create the base class Animal

Write a class called Animal with a public virtual function makeSound() that prints "Some generic animal sound".

C++

# Your code here
// Define class Animal with virtual makeSound()

Need a hint?

Use the keyword virtual before the function makeSound() inside the Animal class.

2

Create derived classes Dog and Cat

Add two classes called Dog and Cat that inherit from Animal. Override the makeSound() function in Dog to print "Woof!" and in Cat to print "Meow!".

C++

#include 
using namespace std;

class Animal {
public:
    virtual void makeSound() {
        cout << "Some generic animal sound" << endl;
    }
};

// Your code here
// Define classes Dog and Cat inheriting Animal and override makeSound()

Need a hint?

Use class Dog : public Animal and class Cat : public Animal. Use override keyword for makeSound().

3

Use Animal pointers to call makeSound()

Create two pointers of type Animal* named dogPtr and catPtr. Point dogPtr to a new Dog object and catPtr to a new Cat object. Call makeSound() using both pointers.

C++

#include 
using namespace std;

class Animal {
public:
    virtual void makeSound() {
        cout << "Some generic animal sound" << endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        cout << "Woof!" << endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        cout << "Meow!" << endl;
    }
};

// Your code here
// Create Animal* pointers dogPtr and catPtr, assign new Dog and Cat, call makeSound()

Need a hint?

Use Animal* dogPtr = new Dog(); and call dogPtr->makeSound();.

4

Print the sounds made by Dog and Cat

Run the program and print the output of calling makeSound() on dogPtr and catPtr. The output should show the correct sounds for Dog and Cat.

C++

#include 
using namespace std;

class Animal {
public:
    virtual void makeSound() {
        cout makeSound();
    catPtr->makeSound();

    delete dogPtr;
    delete catPtr;
    return 0;
}

// Output should be:
// Woof!
// Meow!

Need a hint?

Run the program and check that the output matches exactly Woof! and Meow! on separate lines.