Why inheritance promotes code reuse in Blockchain / Solidity - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Solidity inheritance example

What is the output of this Solidity contract when calling getMessage() from contract Child?

Blockchain / Solidity

pragma solidity ^0.8.0;

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

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

A "Hello from Child"

B Runtime error due to inheritance conflict

C Compilation error due to missing override

D "Hello from Parent"

💡 Hint

Look at which function is called in the Child contract and how override works.

The Child contract overrides the getMessage function from Parent, so calling getMessage on Child returns "Hello from Child".

🧠 Conceptual

intermediate

Why inheritance helps code reuse in smart contracts

Which of the following best explains why inheritance promotes code reuse in blockchain smart contracts?

A It prevents contracts from calling functions of other contracts.

B It forces contracts to duplicate code for security reasons.

C It allows contracts to share and extend existing code without rewriting it.

D It makes contracts run faster by removing all function calls.

💡 Hint

Think about how inheritance lets you build on top of existing code.

Inheritance allows a contract to reuse code from a parent contract, reducing duplication and making development easier.

🔧 Debug

advanced

Identify the error in Solidity inheritance

What error will this Solidity code produce?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Base {
    function greet() public pure returns (string memory) {
        return "Hi";
    }
}

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

A Compilation error: Function must be marked override in Derived

B No error, code compiles and greet returns "Hello"

C Runtime error: greet function not found

D Compilation error: Missing virtual keyword in Base

💡 Hint

Check if the override keyword is used correctly when redefining functions.

No error, code compiles and greet returns "Hello". The function in Derived shadows the one in Base because the Base function is not marked virtual, so override is not required.

📝 Syntax

advanced

Correct syntax for multiple inheritance in Solidity

Which option shows the correct syntax for a contract inheriting from two contracts A and B in Solidity?

A contract C is A, B {}

B contract C inherits A and B {}

C contract C : A, B {}

D contract C extends A, B {}

💡 Hint

Look at how Solidity uses the 'is' keyword for inheritance.

Solidity uses the 'is' keyword followed by comma-separated parent contracts to declare inheritance.

🚀 Application

expert

How inheritance reduces gas costs in smart contracts

How does using inheritance in smart contracts help reduce gas costs during deployment and execution?

A Inheritance disables expensive function calls to save gas.

B Inheritance automatically compresses bytecode to half its size.

C It allows contracts to run off-chain, saving gas.

D By reusing code, contracts avoid duplicating logic, reducing contract size and gas fees.

💡 Hint

Think about how code reuse affects contract size and deployment cost.

Reusing code through inheritance means less repeated code, which reduces contract size and lowers gas costs for deployment and execution.