Why inheritance is used in C++ - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a class Dog that inherits from Animal.

C++

class Dog : public [1] {
};

Drag options to blanks, or click blank then click option'

AAnimal

BDog

CCat

DVehicle

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same class name for inheritance (Dog inherits Dog).

Using unrelated class names like Vehicle.

Inheritance means a class (Dog) gets properties and behaviors from another class (Animal). So Dog inherits from Animal.

2fill in blank

medium

Complete the code to call the base class constructor from the derived class Car.

C++

class Vehicle {
public:
    Vehicle(int wheels) {}
};

class Car : public Vehicle {
public:
    Car() : [1](4) {}
};

Drag options to blanks, or click blank then click option'

ACar

Bint

Cwheels

DVehicle

Attempts:

3 left

💡 Hint

Common Mistakes

Calling the derived class constructor inside itself.

Using variable names instead of class names.

The derived class constructor calls the base class constructor by using the base class name (Vehicle) followed by arguments.

3fill in blank

hard

Fix the error in the code to correctly override the makeSound method in the derived class Cat.

C++

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

class Cat : public Animal {
public:
    [1] void makeSound() override {
        std::cout << "Meow" << std::endl;
    }
};

Drag options to blanks, or click blank then click option'

Aoverride

Bvirtual

Cvoid

Dpublic

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the return type.

Using 'override' keyword without proper syntax.

To override a virtual function, the derived class method should also be declared virtual (optional but good practice) and match the signature. The keyword 'virtual' before the method helps clarity.

4fill in blank

hard

Fill both blanks to create a derived class Bird that inherits publicly from Animal and overrides the fly method.

C++

class Animal {
public:
    virtual void fly() {
        std::cout << "Cannot fly" << std::endl;
    }
};

class Bird : [1] [2] {
public:
    void fly() override {
        std::cout << "Flying high" << std::endl;
    }
};

Drag options to blanks, or click blank then click option'

Apublic

Bprivate

CAnimal

DBird

Attempts:

3 left

💡 Hint

Common Mistakes

Using private inheritance which hides base class methods.

Using the derived class name instead of the base class name.

The class Bird inherits publicly from Animal, so use 'public Animal'. This allows Bird to override the fly method.

5fill in blank

hard

Fill all three blanks to create a dictionary-like map of animal names to their sound lengths, filtering only those with sound length greater than 3.

C++

std::map<std::string, int> soundLengths = {
    {"dog", 3},
    {"elephant", 8},
    {"cat", 3},
    {"bird", 4}
};

std::map<std::string, int> filtered;
for (const auto& [1] : soundLengths) {
    if ([2].second [3] 3) {
        filtered.insert([2]);
    }
}

Drag options to blanks, or click blank then click option'

Aentry

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names inconsistently.

Using < instead of > causing wrong filtering.

We use a loop variable 'entry' to iterate over the map. We check if entry.second (the sound length) is greater than 3, then insert it into filtered.

Practice

1. Why do programmers use inheritance in C++?

easy

A. To create unrelated classes

B. To reuse code from an existing class

C. To make programs run faster

D. To avoid using functions

Solution

1. Step 1: Understand inheritance purpose

   Inheritance allows a new class to use code from an existing class, avoiding repetition.

2. Step 2: Analyze options

   Only To reuse code from an existing class correctly states code reuse. Others are unrelated or incorrect.

3. Final Answer:

   To reuse code from an existing class -> Option B

4. Quick Check:

   Inheritance = Code reuse [OK]

Hint: Inheritance means reusing code from another class [OK]

Common Mistakes:

• Thinking inheritance speeds up program execution
• Confusing inheritance with unrelated class creation
• Believing inheritance removes need for functions

2. Which of the following is the correct syntax to declare a class Car that inherits from class Vehicle in C++?

easy

A. class Car Vehicle {};

B. class Car inherits Vehicle {};

C. class Car extends Vehicle {};

D. class Car : public Vehicle {};

Solution

1. Step 1: Recall C++ inheritance syntax

   In C++, inheritance is declared using a colon and access specifier like public.

2. Step 2: Check each option

   class Car : public Vehicle {}; uses correct syntax. inherits and extends use keywords from other languages. class Car Vehicle {}; is invalid.

3. Final Answer:

   class Car : public Vehicle {}; -> Option D

4. Quick Check:

   C++ inheritance syntax = colon + access specifier [OK]

Hint: Use colon and public keyword for inheritance in C++ [OK]

Common Mistakes:

• Using 'inherits' or 'extends' keywords (not C++ syntax)
• Omitting colon before base class name
• Forgetting access specifier like public

3. Consider this code:

class Animal {
public:
  void sound() { std::cout << "Animal sound"; }
};
class Dog : public Animal {
public:
  void sound() { std::cout << "Bark"; }
};

int main() {
  Dog d;
  d.sound();
  return 0;
}

What is the output when this program runs?

medium

A. Bark

B. Animal sound

C. Compilation error

D. No output

Solution

1. Step 1: Understand method overriding in inheritance

   The Dog class defines its own sound() method, which overrides Animal's method.

2. Step 2: Check which method is called

   Calling d.sound() uses Dog's version, printing "Bark".

3. Final Answer:

   Bark -> Option A

4. Quick Check:

   Overridden method runs = Bark [OK]

Hint: Child class method overrides parent method when called [OK]

Common Mistakes:

• Assuming parent method runs instead of child
• Thinking code causes compilation error
• Expecting no output from method call

4. Find the error in this code snippet:

class Base {
public:
  void show() { std::cout << "Base"; }
};
class Derived : Base {
public:
  void show() { std::cout << "Derived"; }
};

int main() {
  Derived d;
  d.show();
  return 0;
}

medium

A. Derived class cannot have a function named show()

B. Function show() must be virtual

C. No error, code runs fine

D. Missing access specifier before Base in inheritance

Solution

1. Step 1: Verify inheritance syntax

   class Derived : Base is valid syntax; class inheritance defaults to private.

2. Step 2: Trace program execution

   Derived d; d.show(); calls Derived's public show(), printing "Derived". No errors.

3. Final Answer:

   No error, code runs fine -> Option C

4. Quick Check:

   Private inheritance defaults ok here [OK]

Hint: Classes inherit privately by default in C++ [OK]

Common Mistakes:

• Assuming default inheritance is public
• Thinking virtual keyword is mandatory here
• Believing derived class cannot have same function name

5. You want to model a system where Car and Bike share common features like start() and stop(), but also have their own unique features. How should you use inheritance in C++ to design this?

hard

A. Create a base class Vehicle with common features, then inherit Car and Bike from it

B. Make Car inherit from Bike to reuse code

C. Write all features separately in Car and Bike without inheritance

D. Use inheritance only if Car and Bike have identical features

Solution

1. Step 1: Identify common features

   Both Car and Bike share start() and stop(), so these belong in a common base class.

2. Step 2: Design inheritance structure

   Create a base class Vehicle with common features, then inherit Car and Bike from it to add unique features.

3. Final Answer:

   Create a base class Vehicle with common features, then inherit Car and Bike from it -> Option A

4. Quick Check:

   Use base class for shared features [OK]

Hint: Put shared features in base class, inherit for unique parts [OK]

Common Mistakes:

• Inheriting Car from Bike (wrong 'is-a' relationship)
• Duplicating code instead of reusing via inheritance
• Thinking inheritance requires identical features