Function overriding in C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is function overriding in C++?

Function overriding occurs when a derived class provides its own version of a function that is already defined in its base class. The function in the derived class has the same name and parameters as the one in the base class.

beginner

Why do we use function overriding?

We use function overriding to change or extend the behavior of a base class function in a derived class. It allows polymorphism, so the program can decide at runtime which function to call based on the object type.

intermediate

What keyword is used in C++11 and later to explicitly indicate a function is overriding a base class function?

The keyword <code>override</code> is used after the function declaration in the derived class to indicate that the function is meant to override a base class function. This helps catch errors if the base function signature changes.

intermediate

What happens if the base class function is not declared as <code>virtual</code> but the derived class overrides it?

If the base class function is not <code>virtual</code>, then the function call is resolved at compile time (static binding). This means the base class version will be called even if the object is of the derived class type, which is usually not what we want.

beginner

Example: What will be the output of this code?<br><pre>#include &lt;iostream&gt;
class Base { public: virtual void show() { std::cout << "Base"; } }; class Derived : public Base { public: void show() override { std::cout << "Derived"; } }; int main() { Base* b = new Derived(); b->show(); delete b; return 0; }</pre>

The output will be <code>Derived</code>. Because <code>show()</code> is virtual in the base class and overridden in the derived class, the call <code>b->show()</code> uses the derived class version at runtime.

What must be true for function overriding to work correctly in C++?

A The base class function must be declared virtual.

B The derived class function must have a different name.

C The base class function must be private.

D The derived class function must be static.

For runtime polymorphism and proper overriding, the base class function should be declared virtual.

What does the override keyword do in C++?

A It makes the function static.

B It makes the function inline.

C It prevents the function from being overridden.

D It tells the compiler the function is intended to override a base class function.

The override keyword helps the compiler check that the function correctly overrides a base class virtual function.

If a base class function is not virtual, what kind of binding is used when calling it through a base class pointer?

A No binding

B Dynamic binding (runtime)

C Static binding (compile-time)

D Late binding

Without virtual, the function call is resolved at compile time (static binding), so the base class version is called.

Which of these is a correct signature for overriding a base class function void display() const;?

A void display() override;

B void display() const override;

C int display() const override;

D void display(int) const override;

The overriding function must match the base function signature exactly, including const qualifier.

What will happen if you use override keyword but the base class function does not exist?

A Compiler error

B Program runs normally

C Warning only

D Undefined behavior

Using override when no base function matches causes a compiler error, helping catch mistakes.

Explain function overriding and why it is important in C++.

Think about how derived classes change base class behavior.

Describe the difference between function overriding and function overloading.

Focus on how the functions differ in name, parameters, and class relationships.

Practice

1. What is function overriding in C++?

easy

A. A child class provides its own version of a parent class's virtual function.

B. A function with the same name but different parameters in the same class.

C. A function that is called automatically when an object is created.

D. A function that cannot be changed once defined.

Solution

1. Step 1: Understand function overriding concept

   Function overriding means a child class changes the behavior of a function defined in its parent class.

2. Step 2: Identify correct description

   A child class provides its own version of a parent class's virtual function. correctly describes overriding as providing a new version of a parent's virtual function in the child class.

3. Final Answer:

   A child class provides its own version of a parent class's virtual function. -> Option A

4. Quick Check:

   Function overriding = child changes parent's virtual function [OK]

Hint: Overriding means child changes parent's virtual function [OK]

Common Mistakes:

• Confusing overriding with overloading
• Thinking overriding happens without virtual keyword
• Believing overriding applies to non-virtual functions

2. Which of the following is the correct syntax to override a function in C++11 and later?

easy

A. void func() virtual override;

B. override void func();

C. void func() override;

D. virtual void func() override;

Solution

1. Step 1: Recall override syntax in child class

   In C++11+, the child class function uses the same signature and adds the 'override' keyword after the function declaration.

2. Step 2: Identify correct syntax

   virtual void func() override; shows the correct syntax: 'virtual void func() override;'. The 'virtual' keyword can be used in the child class but is optional; however, it is valid and common to include it.

3. Final Answer:

   virtual void func() override; -> Option D

4. Quick Check:

   Child function uses virtual and override keywords correctly [OK]

Hint: Use 'override' after function signature in child class; 'virtual' is optional but allowed [OK]

Common Mistakes:

• Adding 'virtual' keyword after function name
• Placing 'override' before function name
• Omitting 'override' keyword entirely

3. What will be the output of the following code?

class Base {
public:
    virtual void show() { std::cout << "Base"; }
};
class Derived : public Base {
public:
    void show() override { std::cout << "Derived"; }
};
int main() {
    Base* b = new Derived();
    b->show();
    delete b;
    return 0;
}

medium

A. Derived

B. Base

C. Compilation error

D. Runtime error

Solution

1. Step 1: Understand virtual function behavior

   The pointer 'b' is of type Base* but points to a Derived object. Because 'show' is virtual, the Derived version is called.

2. Step 2: Trace the function call

   Calling b->show() invokes Derived::show(), printing "Derived".

3. Final Answer:

   Derived -> Option A

4. Quick Check:

   Virtual function calls child's version [OK]

Hint: Virtual functions call child's version via base pointer [OK]

Common Mistakes:

• Expecting base class output
• Forgetting to make base function virtual
• Confusing pointer type with object type

4. Identify the error in the following code snippet:

class Parent {
public:
    void display() { std::cout << "Parent"; }
};
class Child : public Parent {
public:
    void display() override { std::cout << "Child"; }
};

medium

A. Child's display() should not use override keyword.

B. Parent's display() must be declared virtual to override.

C. display() must return int, not void.

D. No error, code is correct.

Solution

1. Step 1: Check virtual keyword in parent

   For overriding to work, the base class function must be declared virtual.

2. Step 2: Analyze override keyword usage

   Child uses 'override' but Parent's display() is not virtual, causing a compilation error.

3. Final Answer:

   Parent's display() must be declared virtual to override. -> Option B

4. Quick Check:

   Base function must be virtual for override [OK]

Hint: Base function must be virtual to allow override [OK]

Common Mistakes:

• Ignoring virtual keyword in base class
• Thinking override works without virtual
• Assuming override keyword is optional

5. Given the classes below, what will be the output of obj->print();?

class A {
public:
    virtual void print() { std::cout << "A"; }
};
class B : public A {
public:
    void print() override { std::cout << "B"; }
};
class C : public B {
public:
    void print() override { std::cout << "C"; }
};

int main() {
    A* obj = new C();
    obj->print();
    delete obj;
    return 0;
}

hard

A. A

B. B

C. C

D. Compilation error

Solution

1. Step 1: Understand pointer and object types

   Pointer 'obj' is of type A*, but it points to an object of class C.

2. Step 2: Follow virtual function overriding chain

   Since print() is virtual and overridden in B and C, the most derived override (C::print) is called.

3. Final Answer:

   C -> Option C

4. Quick Check:

   Virtual call resolves to most derived override [OK]

Hint: Virtual calls use most derived override at runtime [OK]

Common Mistakes:

• Expecting base class output
• Confusing pointer type with object type
• Ignoring virtual function behavior