solidity – Understanding Virtual and Override Keywords in Solidity

keywordoverridesoliditysolidity-0.6.xvirtual

Solidity 0.6.0 introduced the keywords virtual and override. What do they do?

Best Answer

As of Solidity 0.6.0, the keywords virtual and override are available natively in Solidity for function overriding. The purpose of these keywords is to be more explicit when overriding a function. Base functions can be overridden by inheriting contracts to change their behavior if they are marked as virtual. The overriding function must then use the override keyword in the function header.

These keywords simply allow for more explicit behavior when overriding functions. Prior to version 0.6.0 of Solidity, these keywords did not exist and function overriding was done implicitly. These keywords allow developers to explicitly override functions. Additionally, they allow developers to signal their intent for certain functions so that others have a better understanding of the purpose of the function.

There are a few things to note when using these keywords:

For multiple inheritance, the most derived base contracts that define the same function must be specified explicitly after the override keyword.
Functions with the private visibility cannot be virtual.
Functions without implementation have to be marked virtual outside of interfaces. In interfaces, all functions are automatically considered virtual.

Examples

Simple Example (From Solidity Docs)

pragma solidity >=0.5.0 <0.7.0;

contract Base {
    function foo() virtual public {}
}

contract Middle is Base {}

contract Inherited is Middle {
    function foo() public override {}
}

Multiple Inheritance Example (From Solidity Docs)

pragma solidity >=0.5.0 <0.7.0;

contract Base1 {
    function foo() virtual public {}
}

contract Base2 {
    function foo() virtual public {}
}

contract Inherited is Base1, Base2 {
    // Derives from multiple bases defining foo(), so we must explicitly
    // override it
    function foo() public override(Base1, Base2) {}
}

Related Solutions

Modifiers Override in Solidity – How to Override Parent Methods and Modifiers

Yes, you are correct.

Something I noticed which is worth keeping an eye on is that both modifiers of 'parent' contracts as well as any functions are overwritten by inheritance even when using 'super'.

For example, calling test(0) on B passes and returns 10 (not 5 as one may be led to believe), but fails on contract A.

pragma solidity ^0.4.15;

contract A {
    modifier only (uint test) {
        require(test > 5);
        _;
    }
    function test(uint test) public only(test) returns(uint) {
        return addSome(test);
    }
    function addSome(uint number) internal returns(uint) {
        return number + 5;
    }
}

contract B is A {
    modifier only (uint test) {
        require(test < 10);
        _;
    }
    function test(uint test) public only(test) returns(uint) {
        return super.test(test);
    }
    function addSome(uint number) internal returns(uint) {
        return number + 10;
    }
}

Solidity Keywords – Difference Between Constant and Immutable in Solidity

Both immutable and constant are keywords that can be used on state variables to restrict modifications to their state. The difference is that constant variables can never be changed after compilation, while immutable variables can be set within the constructor.

From the docs:

State variables can be declared as constant or immutable. In both cases, the variables cannot be modified after the contract has been constructed. For constant variables, the value has to be fixed at compile-time, while for immutable, it can still be assigned at construction time.

An example code snippet is as follows:

pragma solidity >0.6.4 <0.7.0;

contract C {
    uint constant X = 32**22 + 8;
    string constant TEXT = "abc";
    bytes32 constant MY_HASH = keccak256("abc");
    uint immutable decimals;
    uint immutable maxBalance;
    address immutable owner = msg.sender;

    constructor(uint _decimals, address _reference) public {
        decimals = _decimals;
        // Assignments to immutables can even access the environment.
        maxBalance = _reference.balance;
    }

    function isBalanceTooHigh(address _other) public view returns (bool) {
        return _other.balance > maxBalance;
    }
}

It is important to note that the compiler does not reserve a storage slot for these variables, and every occurrence is replaced by the respective value.