Base and derived classes in C++ - Step-by-Step Execution

Concept Flow - Base and derived classes

Define Base Class

↓

Define Derived Class

↓

Create Derived Object

↓

Call Derived Method

↓

Call Base Method (inherited)

↓

Use Derived and Base Features

First, we define a base class, then a derived class inherits from it. We create an object of the derived class and use both its own and inherited features.

Execution Sample

C++

#include <iostream>

class Base {
public:
  void greet() { std::cout << "Hello from Base\n"; }
};

class Derived : public Base {
public:
  void greet() { std::cout << "Hello from Derived\n"; }
};

int main() {
  Derived d;
  d.greet();
  d.Base::greet();
  return 0;
}

This code shows a base class and a derived class both with a greet method. The derived class object calls its own greet and the base class greet.

Execution Table

Step	Action	Evaluation	Output
1	Define Base class with greet()	Base::greet() ready
2	Define Derived class inheriting Base, override greet()	Derived::greet() ready
3	Create Derived object d	Object d created
4	Call d.greet()	Calls Derived::greet()	Hello from Derived
5	Call d.Base::greet()	Calls Base::greet() explicitly	Hello from Base
6	Program ends	No more actions

💡 Program ends after calling both greet methods on Derived object

Variable Tracker

Variable	Start	After Creation	After Calls	Final
d (Derived object)	undefined	Created	Used to call greet methods	Exists until program ends

Key Moments - 2 Insights

Why does d.greet() call Derived's greet, not Base's?

Because Derived overrides greet(), so calling d.greet() uses Derived's version (see execution_table step 4).

How can we call Base's greet() from Derived object?

By specifying d.Base::greet(), we tell the program to use Base's greet explicitly (see execution_table step 5).

Visual Quiz - 3 Questions

Look at the execution table, what is printed at step 4 when d.greet() is called?

A Hello from Base

B Hello from Derived

C No output

D Compilation error

💡 Hint

Check the Output column at step 4 in the execution_table

At which step does the program explicitly call the Base class greet() method?

A Step 5

B Step 4

C Step 3

D Step 6

💡 Hint

Look for the action mentioning d.Base::greet() in the execution_table

If Derived did not override greet(), what would d.greet() print?

A Hello from Derived

B No output

C Hello from Base

D Compilation error

💡 Hint

Think about inheritance and method overriding shown in the execution_table steps 4 and 5

Concept Snapshot

Base and derived classes:
- Define base class with methods
- Define derived class inheriting base
- Derived can override base methods
- Derived object uses overridden methods by default
- Use Base::method() to call base version
- Supports code reuse and extension

Full Transcript

This example shows how a derived class inherits from a base class in C++. The base class has a greet method. The derived class overrides this greet method. When we create an object of the derived class and call greet, it uses the derived version. We can also call the base class greet explicitly using the scope operator. This demonstrates basic inheritance and method overriding in C++.

Practice

1. What is the main purpose of a base class in C++?

easy

A. To store only private data members

B. To create objects directly without inheritance

C. To override functions in derived classes

D. To hold common features shared by derived classes

Solution

1. Step 1: Understand base class role

   A base class is designed to hold common features that multiple derived classes can share.

2. Step 2: Compare options

   To hold common features shared by derived classes correctly states the purpose. Other options describe derived class behavior or incorrect roles.

3. Final Answer:

   To hold common features shared by derived classes -> Option D

4. Quick Check:

   Base class = common features [OK]

Hint: Base class holds shared features for reuse [OK]

Common Mistakes:

• Confusing base class with derived class
• Thinking base class cannot have data members
• Assuming base class is only for private data

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

easy

A. class Car : Vehicle {};

B. class Car : public Vehicle {};

C. class Car extends Vehicle {};

D. class Car inherits Vehicle {};

Solution

1. Step 1: Recall C++ inheritance syntax

   In C++, a derived class inherits from a base class using a colon and access specifier like public.

2. Step 2: Check options

   class Car : public Vehicle {}; uses correct syntax: class Car : public Vehicle {}. Others use incorrect keywords or omit access specifier.

3. Final Answer:

   class Car : public Vehicle {} -> Option B

4. Quick Check:

   Inheritance syntax = colon + access specifier [OK]

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

Common Mistakes:

• Omitting access specifier like public
• Using wrong keywords like inherits or extends
• Forgetting colon before base class name

3. What will be the output of this C++ code?

class Base {
public:
    void show() { std::cout << "Base"; }
};
class Derived : public Base {
public:
    void show() { std::cout << "Derived"; }
};
int main() {
    Derived d;
    d.show();
    return 0;
}

medium

A. Derived

B. Base

C. Compilation error

D. No output

Solution

1. Step 1: Understand method overriding in derived class

   The derived class Derived has its own show() method which hides the base class method.

2. Step 2: Check which method is called

   Calling d.show() on a Derived object calls the derived class method, printing "Derived".

3. Final Answer:

   Derived -> Option A

4. Quick Check:

   Derived method overrides base method [OK]

Hint: Derived class method hides base method if same name [OK]

Common Mistakes:

• Assuming base class method runs without virtual keyword
• Expecting compilation error due to method name clash
• Thinking both outputs print

4. Identify the error in this code snippet:

class Base {
public:
    void display() { std::cout << "Base"; }
};
class Derived : public Base {
public:
    void display() { std::cout << "Derived"; }
};
int main() {
    Base* ptr = new Derived();
    ptr->display();
    return 0;
}

medium

A. Missing virtual keyword in base class method

B. Incorrect pointer type for inheritance

C. Derived class method should be static

D. No error, code runs fine

Solution

1. Step 1: Understand polymorphism with base pointers

   Calling display() via a base class pointer calls base method unless it is virtual.

2. Step 2: Check for virtual keyword

   The base class method display() lacks virtual, so ptr->display() calls base version, not derived.

3. Final Answer:

   Missing virtual keyword in base class method -> Option A

4. Quick Check:

   Virtual needed for polymorphic calls [OK]

Hint: Add virtual to base method for polymorphism [OK]

Common Mistakes:

• Thinking pointer type is wrong
• Believing derived method runs without virtual
• Assuming static keyword fixes this

5. Given these classes:

class Animal {
public:
    virtual std::string sound() { return "Unknown"; }
};
class Dog : public Animal {
public:
    std::string sound() override { return "Bark"; }
};
class Cat : public Animal {
public:
    std::string sound() override { return "Meow"; }
};

Which code snippet correctly creates a list of animals and prints their sounds?

hard

A. std::vector<Animal> animals = {Dog(), Cat()}; for(auto& a : animals) std::cout << a.sound() << ' ';

B. std::vector<Dog> animals = {Dog(), Cat()}; for(auto& a : animals) std::cout << a.sound() << ' ';

C. std::vector animals = {new Dog(), new Cat()}; for(auto a : animals) std::cout << a->sound() << ' ';

D. std::vector<Animal> animals = {Dog(), Cat()}; for(auto a : animals) std::cout << a.sound() << ' ';

Solution

1. Step 1: Understand polymorphism with collections

   To preserve derived class behavior, store pointers to base class, not objects by value.

2. Step 2: Analyze options

   std::vector animals = {new Dog(), new Cat()}; for(auto a : animals) std::cout << a->sound() << ' '; uses std::vector<Animal*> with pointers to Dog and Cat, calling sound() polymorphically.

3. Final Answer:

   std::vector<Animal*> animals = {new Dog(), new Cat()}; for(auto a : animals) std::cout << a->sound() << ' '; -> Option C

4. Quick Check:

   Use base class pointers for polymorphic containers [OK]

Hint: Use base class pointers to keep derived behavior [OK]

Common Mistakes:

• Storing objects by value causes slicing
• Using wrong container type for polymorphism
• Forgetting to use pointers or references