Building on your understanding of functions in Solidity from the previous steps, you're now going to learn how to:

create view functions to read data from a smart contract without modifying it.
create payable functions to retrieve and transfer Ether.
use function overloading to define multiple functions with the same name but different parameters.

With this knowledge, you will be better equipped to develop more efficient, secure, and maintainable smart contracts.

Decorative: An image of a juicer representing the role of functions in programming. The juicer takes an apple, processes it, and returns apple juice.

View functions

Functions declared with the view keyword ensure that the state of a contract will not be modified. If a compiler identifies that a function body attempts to modify state, even though the function is declared as view, the compiler will throw a warning.

The following statements are considered modifying the state:

writing to state variables.
emitting events.
creating other contracts.
using selfdestruct.
sending Ether via calls.
calling any function not marked view or pure.
using low-level calls.
using inline assembly that contains certain opcodes.

Example:

pragma solidity ^0.8.0;
contract ExampleContract {
    uint private myNumber = 42;
    function getMyNumber() public view returns (uint) {
        myNumber = myNumber + 2; //warning
        return myNumber;
    }
}

There is a problem with the above function though. The myNumber variable is modified inside the function with the line myNumber = myNumber + 2;. This is not allowed because the function is declared as a view function, which means it is meant to only read data from the contract and not modify any state. This would result in a compiler warning.

To fix this issue, the view keyword should be removed from the function declaration and replaced with the pure keyword if the function doesn't read any state from the contract.

Payable functions

In Solidity, payable functions are the ones that can receive Ether (the cryptocurrency of the Ethereum network) as a parameter and can also send Ether as a result. These functions are marked with the payable keyword.

The function can use the msg.value attribute to determine the amount of Ether that was sent with the transaction and perform any necessary actions based on that value. If the ‘payable’ keyword is not declared, function cannot use msg.value attribute.

Note:

In addition to checking msg.value, it is also necessary to put a check to verify if the amount of Ether sent is not zero, and also to check if the contract has enough balance to execute certain operations, if any.

Function overloading

Function overloading in Solidity is a feature that allows multiple functions with the same name to be defined in a contract, but with different parameter types or different number of parameters. For example:

   function foo(uint a) public {
      // ...
   }
   function foo(uint a, uint b) public {
      // ...
   }
   function foo(string memory a) public {
      // ...
   }

Function overriding

In Solidity, function overriding refers to the ability of a derived contract to redefine a function that is already defined in its parent contract. When a function is overridden, the derived contract provides its own implementation of the function, which replaces the implementation inherited from the parent contract.

To override a function in Solidity, you need to follow these rules:

the function in the parent contract must be declared as virtual.
the function in the derived contract must be declared as override.
the function signatures (name and parameter types) in both contracts must match.

The virtual keyword in the parent contract indicates that the function can be overridden by derived contracts. It allows the function to be redefined without introducing a new function with a different name.

The override keyword in the derived contract is used to explicitly indicate that you are overriding a function from the parent contract. It ensures that the function being defined in the derived contract is intended to override the parent's function.

When a function is overridden, the derived contract can provide its own implementation, which will be used when calling the function on instances of the derived contract. This allows you to customise the behaviour of the inherited function to suit the specific needs of the derived contract.

It's important to note that function overriding only applies to functions marked as virtual in the parent contract. If a function is not marked as virtual, it cannot be overridden. Additionally, you can use the super keyword in the derived contract to explicitly call the overridden function from the parent contract if you still want to execute the parent's implementation.

contract Parent {
    function foo() public virtual returns (string memory) {
        return "Parent";
    }
}
 
contract Child is Parent {
    function foo() public virtual override returns (string memory) {
        string memory joint = string.concat(super.foo(), " Child");
        return joint;
    }
}

Decorative: Reflect banner

Reflect on the different types of functions available in Solidity, such as view, pure, and payable functions.

How do these function types differ in terms of their purpose, behaviour, and interaction with the contract's state and external systems?

Think of examples to illustrate the use cases for each function type. You can view the sample answer in the next step.

When you’re ready, select Next to continue.

Advanced function features part 2

SELF PACED PLATFORM

TRAINING CONTENT

JOB ROLE PATHS

CERTIFICATIONS