Function overloading in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of overloaded function calls in Solidity

Consider the following Solidity contract with overloaded functions named calculate. What will be the output when calling calculate(5) and calculate(5, 10)?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract OverloadExample {
    function calculate(uint x) public pure returns (uint) {
        return x * 2;
    }

    function calculate(uint x, uint y) public pure returns (uint) {
        return x + y;
    }
}

A calculate(5) returns 5; calculate(5, 10) returns 50

B calculate(5) returns 10; calculate(5, 10) returns 50

C calculate(5) returns 10; calculate(5, 10) returns 15

D calculate(5) returns 5; calculate(5, 10) returns 15

💡 Hint

Look at how each function processes its parameters: one doubles a single number, the other adds two numbers.

The first calculate function takes one argument and returns it multiplied by 2. So calculate(5) returns 10. The second takes two arguments and returns their sum, so calculate(5, 10) returns 15.

❓ Predict Output

intermediate

Function overloading with different parameter types

Given this Solidity contract, what is the output of calling getValue(3) and getValue(true)?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract TypeOverload {
    function getValue(uint x) public pure returns (string memory) {
        return "Number";
    }

    function getValue(bool b) public pure returns (string memory) {
        return "Boolean";
    }
}

A Both calls return "Boolean"

B getValue(3) returns "Number"; getValue(true) returns "Boolean"

C Both calls return "Number"

D getValue(3) returns "Boolean"; getValue(true) returns "Number"

💡 Hint

Functions are chosen based on the parameter type passed.

The function getValue is overloaded by parameter type. Passing a uint calls the first function returning "Number". Passing a bool calls the second returning "Boolean".

🔧 Debug

advanced

Identify the error in overloaded functions

Examine this Solidity contract with overloaded functions. What error will the compiler produce?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract ErrorExample {
    function foo(uint x) public pure returns (uint) {
        return x + 1;
    }

    function foo(uint y) public pure returns (uint) {
        return y + 2;
    }
}

A Compiler warning: Function is deprecated

B Runtime error: Ambiguous function call

C No error, compiles and runs fine

D Compiler error: Function with same name and parameter types already defined

💡 Hint

Check if the parameter lists differ between the two functions.

Both functions have the same name and identical parameter types (uint). Solidity does not allow overloading functions with the same parameter types, causing a compiler error.

📝 Syntax

advanced

Correct syntax for overloaded functions in Solidity

Which option shows the correct syntax for two overloaded functions named transfer in Solidity?

A

function transfer(address to, uint amount) public {}
function transfer(address to, uint amount, bool flag) public {}

B

function transfer(address to, uint amount) public {}
function transfer(uint amount, address to) public {}

C

function transfer(address to, uint amount) public {}
function transfer(address to) public {}

D

function transfer(address to, uint amount) public {}
function transfer(address to, uint amount) public {}

💡 Hint

Overloaded functions must differ in parameter types or number of parameters.

Option A shows two functions with the same name but different parameter counts, which is valid overloading. Option A differs only by missing a parameter, which is valid. Option A differs only by parameter order but same types, which is valid in Solidity. Option A duplicates the exact signature, causing an error.

🚀 Application

expert

Designing overloaded functions for token transfers

You want to design a Solidity contract with overloaded sendTokens functions:

• One function sends tokens to a single address.
• Another sends tokens to multiple addresses with amounts.

Which option correctly declares these overloaded functions?

A

function sendTokens(address to, uint amount) public {}
function sendTokens(address[] memory recipients, uint[] memory amounts) public {}

B

function sendTokens(address to, uint amount) public {}
function sendTokens(address[] recipients, uint[] amounts) public {}

C

function sendTokens(address to, uint amount) public {}
function sendTokens(address[] memory recipients, uint amount) public {}

D

function sendTokens(address to, uint amount) public {}
function sendTokens(address to, uint amount, bool batch) public {}

💡 Hint

Remember to use memory keyword for array parameters in Solidity.

Option A correctly declares two overloaded functions: one for single transfers and one for batch transfers using arrays with memory keyword. Option A misses memory keyword, causing a compiler error. Option A changes parameter types incorrectly. Option A uses a boolean flag instead of arrays, which is not overloading by parameter types but by parameter count.