Virtual and Override Functions

In Solidity, virtual and override are keywords used in inheritance to manage function overriding. They allow derived contracts to modify or extend the behavior of functions defined in base contracts.

1. Virtual Functions

A virtual function is a function in a base contract that can be overridden by a derived contract. By default, functions in Solidity cannot be overridden unless marked with the virtual keyword.

Key Points:

Declared in a base contract using virtual.
Signals that derived contracts may override this function.

Example: Virtual Function


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Animal {
    // Function marked as virtual to allow overriding
    function makeSound() public pure virtual returns (string memory) {
        return "Some generic animal sound";
    }
}

2. Override Functions

An override function is a function in a derived contract that redefines a virtual function from a base contract. The override keyword ensures that Solidity checks at compile time that a corresponding virtual function exists in the base contract.

Key Points:

Must match the function signature of the virtual function.
Ensures safe and explicit overriding.

Example: Override Function


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Dog is Animal {
    // Overriding the virtual function from base contract
    function makeSound() public pure override returns (string memory) {
        return "Bark!";
    }
}

Explanation:

makeSound() in Dog overrides the makeSound() in Animal.
Calling makeSound() on a Dog contract returns "Bark!" instead of the generic sound.

3. Multiple Inheritance with Virtual & Override

When using multiple inheritance, you must explicitly override all base functions that are marked as virtual. Solidity uses C3 linearization to determine the order of inheritance.


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

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

contract B is A {
    function greet() public pure virtual override returns (string memory) {
        return "Hello from B";
    }
}

contract C is A, B {
    function greet() public pure override(A, B) returns (string memory) {
        return "Hello from C";
    }
}