Virtual and override keywords in Blockchain / Solidity - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the virtual keyword do in a blockchain smart contract?

It marks a function that can be changed (overridden) by a contract that inherits from this one. Think of it like a placeholder that child contracts can customize.

beginner

What is the purpose of the override keyword in a derived contract?

It tells the blockchain compiler that this function replaces a virtual function from a parent contract. It’s like saying, "I’m changing how this works here."

intermediate

Can a function be overridden if it is not marked as virtual in the parent contract?

No. Only functions marked as virtual can be overridden. This protects important functions from accidental changes.

intermediate

Why is it important to use override explicitly when changing a function?

It helps avoid mistakes by making sure you really mean to replace a parent function. The compiler checks this and gives an error if you forget it.

beginner

Example: What happens if a child contract overrides a virtual function but forgets to use override keyword?

The compiler will give an error and won’t let the contract compile. This prevents accidental mistakes in your smart contract code.

What keyword must a parent contract use to allow a function to be changed by a child contract?

A virtual

B override

C final

D static

The virtual keyword marks a function as changeable by child contracts.

Which keyword must a child contract use when it changes a parent's virtual function?

A override

B virtual

C abstract

D static

The override keyword tells the compiler you are replacing a parent's virtual function.

What happens if you override a function but forget to use override keyword?

A The contract compiles fine

B The compiler gives an error

C The function runs twice

D The function is ignored

The compiler requires override to confirm you want to replace the parent's function.

Can a function without virtual be overridden?

A Yes, always

B Only if it is private

C Only if marked <code>override</code>

D No, it cannot be overridden

Functions must be marked virtual to be overridden.

Why do blockchain languages require explicit virtual and override keywords?

A To make code run faster

B To allow private functions

C To prevent accidental function changes

D To save storage space

Explicit keywords help avoid mistakes by making function changes clear and checked by the compiler.

Explain in your own words how the virtual and override keywords work together in blockchain smart contracts.

Think about how a parent contract allows children to customize behavior safely.

Why is it important to mark functions as virtual before allowing them to be overridden?

Consider what could happen if any function could be changed without warning.

Practice

1. What does the virtual keyword do in a blockchain smart contract?

easy

A. Makes a function private

B. Prevents a function from being changed

C. Deletes a function from the contract

D. Allows a function to be changed in child contracts

Solution

1. Step 1: Understand the role of virtual

   The virtual keyword marks a function so child contracts can change it.

2. Step 2: Compare with other options

   Options B, C, and D describe behaviors that virtual does not do.

3. Final Answer:

   Allows a function to be changed in child contracts -> Option D

4. Quick Check:

   virtual = allows override [OK]

Hint: Virtual means function can be changed later [OK]

Common Mistakes:

• Thinking virtual makes function private
• Confusing virtual with override
• Believing virtual deletes functions

2. Which of the following is the correct way to override a virtual function named transfer in a child contract?

easy

A. function transfer() public virtual { }

B. function transfer() public override { }

C. function transfer() public final { }

D. function transfer() public abstract { }

Solution

1. Step 1: Identify override syntax

   To replace a virtual function, use override keyword in the child function.

2. Step 2: Check options

   function transfer() public override { } uses override, correct for overriding. function transfer() public virtual { } uses virtual which allows override but does not override itself. Options C and D are incorrect keywords here.

3. Final Answer:

   function transfer() public override { } -> Option B

4. Quick Check:

   Override keyword replaces virtual function [OK]

Hint: Use override keyword to replace virtual function [OK]

Common Mistakes:

• Using virtual instead of override to replace function
• Using final or abstract incorrectly
• Omitting override keyword

3. Consider this Solidity code snippet:

contract Parent {
    function greet() public virtual returns (string memory) {
        return "Hello from Parent";
    }
}

contract Child is Parent {
    function greet() public override returns (string memory) {
        return "Hello from Child";
    }
}

contract Test {
    function testGreet() public returns (string memory) {
        Child c = new Child();
        return c.greet();
    }
}

What will testGreet() return when called?

medium

A. "Hello from Parent"

B. Compilation error

C. "Hello from Child"

D. Runtime error

Solution

1. Step 1: Understand virtual and override behavior

   The greet function in Parent is marked virtual, allowing Child to override it.

2. Step 2: Check which function is called

   When c.greet() is called on a Child instance, the overridden greet in Child runs, returning "Hello from Child".

3. Final Answer:

   "Hello from Child" -> Option C

4. Quick Check:

   Override function runs on child instance [OK]

Hint: Child override runs, not parent virtual function [OK]

Common Mistakes:

• Expecting parent function output
• Thinking override causes error
• Confusing virtual with abstract

4. What is wrong with this Solidity code?

contract Base {
    function foo() public virtual returns (string memory) {
        return "Base";
    }
}

contract Derived is Base {
    function foo() public returns (string memory) {
        return "Derived";
    }
}

medium

A. Missing override keyword in Derived's foo function

B. Base's foo function should not be virtual

C. Derived's foo function should be private

D. No errors, code is correct

Solution

1. Step 1: Check override rules

   Since foo in Base is virtual, the overriding function in Derived must use override keyword.

2. Step 2: Identify missing keyword

   The foo function in Derived lacks override, causing a compilation error.

3. Final Answer:

   Missing override keyword in Derived's foo function -> Option A

4. Quick Check:

   Override keyword required when replacing virtual function [OK]

Hint: Override keyword is mandatory when replacing virtual functions [OK]

Common Mistakes:

• Forgetting override keyword
• Thinking virtual is optional in base
• Making function private incorrectly

5. You have a contract hierarchy:

contract A {
    function calc() public virtual returns (uint) {
        return 1;
    }
}

contract B is A {
    function calc() public virtual override returns (uint) {
        return 2;
    }
}

contract C is B {
    function calc() public override returns (uint) {
        return 3;
    }
}

If you call calc() on a C contract instance, what is the output and why?

hard

A. 3, because C overrides B's function

B. 1, because A's function is virtual

C. 2, because B overrides A and is virtual

D. Compilation error due to multiple overrides

Solution

1. Step 1: Trace overrides in inheritance

   Contract A defines calc as virtual. B overrides it and keeps it virtual. C overrides B's version without virtual.

2. Step 2: Determine which function runs on C instance

   Calling calc() on C runs C's override, returning 3.

3. Final Answer:

   3, because C overrides B's function -> Option A

4. Quick Check:

   Most derived override runs on instance [OK]

Hint: Most derived override runs, even if base is virtual [OK]

Common Mistakes:

• Thinking base virtual function runs
• Confusing virtual with override
• Expecting compilation error from multiple overrides