Inheritance In Solidity

 

Inheritance is the most important feature of object-oriented programming. It is used to decouple the code, reduce the dependency, and increase the re-usability of existing code. Solidity provides inheritance between smart contracts; you can write multiple contracts and inherit into a single one. The contract from where other contracts inherit the features called base contract; the contract which inherits the features known as a derived contract—in a slightly different language, people often referred it as a parent and child contract, respectively.

 

In Solidity, inheritance scope is limited with public and internal access modifiers, meaning that only public and internal properties of a base contract are available to the derived contract.

 

The Solidity compiler compiles all base contracts code into a single contract and that single contract goes to the blockchain.

 

How to use inheritance in Solidity?

 

Solidity has the “is” keyword to inherit the base contract to the derived contract. 

contract baseContract {
    //parent contract
}
contract derivedContract is baseContract {
    //child contract
}

Example

pragma solidity >=0.4.22 <0.6.0;

contract parent{
    uint internal id;
    function setValue(uint _value) public{
        id = _value;
    }
}
contract child is parent{
    function getValue() public view returns(uint){
        return id;
    }
}

To check if the parent contract code compiles into a child contract or not, deploy the parent contract first and then child contract. You’ll see the difference; parent contract only contains the method "setValue", whereas, child contract contains both the method of its own and of the parent contract. 

 

 

 

Solidity supports different types of inheritance

• Single Inheritance
• Multi-level Inheritance
• Hierarchical Inheritance
• Multiple Inheritance

Single Inheritance

 

Single or single-level inheritance helps to use variables and functions of the base contract to the derived contract. 

 

 

Let’s change our previous code snippet and try to understand the usage of the single inheritance. 

pragma solidity >=0.4.22 <0.6.0;

contract parent{

    uint internal id;

    function setValue(uint _value) external {
        id = _value;
    }
}

contract child is parent{

    function getValue() external view returns(uint) {
        return id;
    }
}

contract caller {
    child cc = new child();

    function testInheritance(uint _input) public returns (uint) {
        cc.setValue(_input);
        return cc.getValue();
    }
}

Things to notice -

• Functions setValue and getValue are defined as external.
• Added third contract "caller" to call functions of the base and parent contract.
• Created an object of the child contract named "cc".
• Added method "testInheritance", using by we will set and get the value of the id variable.

Now, let's jump to the Remix IDE, paste our example code, and deploy the "caller" contract. Once it is deployed, you should see the screen as below.

 

 

Add value—15 in the upper screen—to the method “testInheritance”, hit the method, and check the terminal, you should see the same value that you passed to the method. Here, the value of the variable “id” has been updated, and that we have accessed it from the child contract.

 

Multi-level Inheritance

 

Multi-level inheritance is similar to the single level, but the difference is, it has levels of parent-child relationships. The child contract—derived from a parent contract—also acts as a parent contract of another contract. Take a look at the following diagram: 

 

 

Contract A is the parent of B, and contract B is the parent of contract C. 

 

Example

pragma solidity >=0.4.22 <0.6.0;

contract A {
    function getAValue() external pure returns(string memory){
        return "contract A is called";
    }
}

contract B is A {

    function getBValue() external pure returns(string memory){
        return "contract B is called";
    }
}

contract C is B {

    function getCValue() external pure returns(string memory){
        return "contract C is called";
    }
}


contract caller {

    C contractC = new C();

    function testInheritance() public view returns (string memory, string memory, string memory) {
        return (contractC.getAValue(), contractC.getBValue(), contractC.getCValue());
    }
}

Here in this example, we have called functions of contracts A, B, and C from the “caller”. The execution of the above code will give the following results:

 

 

Hierarchical Inheritance

 

In hierarchical inheritance, the base contract has over one derived contract. This inheritance is useful when one common functionality is used in multiple places. The following diagram is displayed the type hierarchical, where a single contract is a parent of multiple child contracts.

 

 

Example:

pragma solidity >=0.4.22 <0.6.0;

contract A {
    function getAValue() external pure returns(string memory){
        return "contract A is called";
    }
} contract B is A {

} contract C is A {

}
contract caller {
    B contractB = new B();
    C contractC = new C();

    function testInheritance() public view returns (string memory, string memory) {
        return (contractB.getAValue(), contractC.getAValue());
    }
}

Output

 

 

 

Multiple Inheritance 

 

Unlike C# and Java, Solidity supports multiple-inheritance. The single contract can be inherited from more than one contract. Here, in the following diagram, shown is the multiple-inheritance. 

 

 

Example

pragma solidity >=0.4.22 <0.6.0;

contract A {

    uint internal a;

    function getA(uint _value) external {
        a = _value;
    }
}

contract B {

    uint internal b;

    function getB(uint _value) external{
        b = _value;
    }
}

contract C is A, B {

    function getValueOfSum() external view returns(uint) {
        return a + b;
    }
}

contract caller {

    C contractC = new C();

    function testInheritance() public returns(uint) {
        contractC.getA(10);
        contractC.getB(20);
        return contractC.getValueOfSum();
    }
}

Execution of the above code will give an output as expected "30", you can see that in the terminal window as follows,

 

 

Summary

 

In this article, we have seen the following points,

• Usage of the “is” keyword in Solidity
• Types of inheritance support in Solidity
• How to use a single, multi-level, hierarchical and multiple inheritance.

In the next article, we’ll discuss another most important topic—Interface in Solidity. Stay tuned!