Contract inheritance in Blockchain / Solidity - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is contract inheritance in blockchain programming?

Contract inheritance allows a new contract to reuse code and properties from an existing contract, making development easier and more organized.

beginner

How do you declare inheritance in Solidity?

You declare inheritance by adding the parent contract name in parentheses after the child contract name, like contract Child is Parent { }.

intermediate

What happens if both parent and child contracts have a function with the same name?

The child contract's function overrides the parent's function, allowing customization or extension of behavior.

intermediate

Can a contract inherit from multiple contracts in Solidity?

Yes, Solidity supports multiple inheritance by listing multiple parent contracts separated by commas, like contract Child is Parent1, Parent2 { }.

beginner

Why is contract inheritance useful in blockchain development?

It helps reuse code, reduce errors, organize contracts better, and build complex systems by combining simple contracts.

How do you specify that a contract inherits from another in Solidity?

A By using the 'extends' keyword

B By using the 'is' keyword followed by the parent contract name

C By importing the parent contract only

D By declaring a function with the parent's name

In Solidity, inheritance is declared using the 'is' keyword followed by the parent contract name.

What happens if a child contract defines a function with the same name as its parent?

A The parent's function is called automatically

B Both functions run in sequence

C The child's function overrides the parent's function

D It causes a compilation error

The child's function overrides the parent's function, allowing the child to customize behavior.

Can a Solidity contract inherit from more than one contract?

A Yes, by listing multiple contracts separated by commas

B No, only single inheritance is allowed

C Yes, but only if contracts are in the same file

D No, inheritance is not supported in Solidity

Solidity supports multiple inheritance by listing parent contracts separated by commas.

Which of these is NOT a benefit of contract inheritance?

A Automatic gas fee reduction

B Better organization

C Easier maintenance

D Code reuse

Inheritance helps with code reuse and organization but does not automatically reduce gas fees.

If a contract inherits from two parents that have a function with the same name, how does Solidity decide which one to use?

A It merges both functions automatically

B It uses the function from the last parent listed

C It uses the function from the first parent listed

D It causes a compilation error unless overridden

Solidity requires the child contract to override the function to resolve conflicts from multiple inheritance.

Explain how contract inheritance works in Solidity and why it is useful.

Think about how a child contract can use and change code from a parent contract.

Describe what happens when two parent contracts have the same function name and a child contract inherits from both.

Consider how Solidity handles conflicts in multiple inheritance.

Practice

1. What keyword is used in Solidity to inherit from a parent contract?

easy

A. extends

B. inherits

C. is

D. implements

Solution

1. Step 1: Understand Solidity inheritance syntax

   In Solidity, the keyword is is used to inherit from a parent contract.

2. Step 2: Compare with other options

   Keywords like extends, inherits, and implements are not used in Solidity for inheritance.

3. Final Answer:

   is -> Option C

4. Quick Check:

   Inheritance keyword = is [OK]

Hint: Remember: Solidity uses 'is' for inheritance [OK]

Common Mistakes:

• Confusing Solidity with other languages like Java using 'extends'
• Using 'implements' which is for interfaces
• Trying 'inherits' which is not a Solidity keyword

2. Which of the following is the correct way to declare a function in a parent contract that can be overridden in Solidity?

easy

A. function foo() public virtual {}

B. function foo() public abstract {}

C. function foo() public override {}

D. function foo() public final {}

Solution

1. Step 1: Identify the keyword to allow overriding

   In Solidity, to allow a function to be overridden in child contracts, it must be marked virtual.

2. Step 2: Check other options for correctness

   override is used in child contracts, abstract is for abstract contracts, and final is not a Solidity keyword.

3. Final Answer:

   function foo() public virtual {} -> Option A

4. Quick Check:

   Allow override = virtual [OK]

Hint: Use 'virtual' in parent to allow overrides [OK]

Common Mistakes:

• Using 'override' in parent instead of child
• Confusing 'abstract' with 'virtual'
• Using non-existent 'final' keyword

3. What will be the output of the following Solidity code when calling greet() on contract Child?

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";
    }
}

medium

A. Runtime error

B. "Hello from Parent"

C. Compilation error due to missing override

D. "Hello from Child"

Solution

1. Step 1: Understand function overriding

   The Child contract overrides the greet() function from Parent using override keyword.

2. Step 2: Determine which function runs on Child

   Calling greet() on Child runs the overridden function returning "Hello from Child".

3. Final Answer:

   "Hello from Child" -> Option D

4. Quick Check:

   Override function output = "Hello from Child" [OK]

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

Common Mistakes:

• Thinking parent function runs instead of child
• Missing 'override' keyword causing compile error
• Expecting runtime error without cause

4. Identify the error in the following Solidity code snippet:

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. Missing 'virtual' keyword in Base's foo function

C. Derived contract should not inherit Base

D. Function foo should be private

Solution

1. Step 1: Check overriding rules in Solidity

   When overriding a function marked virtual in the parent, the child function must use override keyword.

2. Step 2: Identify missing keyword

   The foo() function in Derived lacks the override keyword, causing a compilation error.

3. Final Answer:

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

4. Quick Check:

   Override missing = compile error [OK]

Hint: Override functions must use 'override' keyword [OK]

Common Mistakes:

• Forgetting 'override' keyword in child function
• Thinking 'virtual' is needed in child function
• Assuming inheritance itself causes error

5. Given the following contracts, what will be the output of calling getMessage() on contract GrandChild?

contract Parent {
    function getMessage() public virtual returns (string memory) {
        return "Parent";
    }
}

contract Child is Parent {
    function getMessage() public virtual override returns (string memory) {
        return "Child";
    }
}

contract GrandChild is Child {
    function getMessage() public override returns (string memory) {
        return super.getMessage();
    }
}

hard

A. "Parent"

B. "Child"

C. "GrandChild"

D. Compilation error due to missing virtual

Solution

1. Step 1: Understand super keyword in Solidity inheritance

   The GrandChild contract calls super.getMessage(), which refers to the immediate parent Child implementation.

2. Step 2: Identify which function runs

   The Child contract's getMessage() returns "Child", so GrandChild returns "Child" as well.

3. Final Answer:

   "Child" -> Option B

4. Quick Check:

   super calls immediate parent = "Child" [OK]

Hint: super calls immediate parent function [OK]

Common Mistakes:

• Thinking super calls grandparent function
• Expecting 'GrandChild' string without override
• Missing 'virtual' in intermediate contract causing error