Function overloading in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a function named add that takes two uint parameters.

Blockchain / Solidity

function add(uint a, uint b) public pure returns (uint) {
    return a [1] b;
}

Drag options to blanks, or click blank then click option'

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition.

Forgetting to return the result.

The add function should return the sum of a and b. The plus sign + adds two numbers.

2fill in blank

medium

Complete the code to overload the add function to accept three uint parameters.

Blockchain / Solidity

function add(uint a, uint b, uint c) public pure returns (uint) {
    return a [1] b [2] c;
}

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using different operators for each addition.

Using subtraction or multiplication instead of addition.

The overloaded add function adds three numbers. Both operators should be + to sum all three parameters.

3fill in blank

hard

Fix the error in the overloaded add function that takes two string parameters and returns their concatenation.

Blockchain / Solidity

function add(string memory a, string memory b) public pure returns (string memory) {
    return string(abi.encodePacked(a [1] b));
}

Drag options to blanks, or click blank then click option'

A.

B+

C,

D&

Attempts:

3 left

💡 Hint

Common Mistakes

Using plus sign + to concatenate strings in Solidity.

Using dot or ampersand which are invalid here.

In Solidity, abi.encodePacked takes multiple arguments separated by commas to concatenate strings. The comma , is correct here.

4fill in blank

hard

Fill both blanks to create an overloaded add function that takes two int parameters and returns their sum.

Blockchain / Solidity

function add(int a, int b) public pure returns (int) {
    return a [1] b;
}

function add(int a, int b, int c) public pure returns (int) {
    return a [2] b + c;
}

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using different operators in each function.

Using subtraction or multiplication instead of addition.

Both functions add their int parameters using the plus operator +.

5fill in blank

hard

Fill both blanks to create an overloaded add function that takes two uint parameters and returns their sum, and another that takes two string parameters and returns their concatenation.

Blockchain / Solidity

function add(uint a, uint b) public pure returns (uint) {
    return a [1] b;
}

function add(string memory a, string memory b) public pure returns (string memory) {
    return string(abi.encodePacked(a,b));
}

function add(uint a, uint b, uint c) public pure returns (uint) {
    return a [2] b + c;
}

Drag options to blanks, or click blank then click option'

A+

B,

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using plus sign to concatenate strings instead of comma.

Using subtraction or multiplication instead of addition for numbers.

The first and third functions add numbers using +. The second function concatenates strings using abi.encodePacked with arguments separated by a comma ,.

Practice

1. What is function overloading in blockchain smart contracts?

easy

A. Writing functions without any input parameters

B. Defining multiple functions with the same name but different inputs

C. Calling a function from another contract

D. Using the same function name for different contracts

Solution

1. Step 1: Understand the term 'function overloading'

   Function overloading means having multiple functions with the same name but different input types or counts.

2. Step 2: Apply this to blockchain smart contracts

   In smart contracts, this allows handling different input scenarios with one function name.

3. Final Answer:

   Defining multiple functions with the same name but different inputs -> Option B

4. Quick Check:

   Function overloading = same name, different inputs [OK]

Hint: Same name, different inputs means overloading [OK]

Common Mistakes:

• Confusing overloading with calling functions
• Thinking overloading means same inputs
• Mixing overloading with inheritance

2. Which of the following is the correct syntax for function overloading in Solidity?

easy

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

B. function transfer(uint amount) public {} function transfer(uint amount) private {}

C. function transfer(uint amount) public {} function transfer(uint amount) public {}

D. function transfer() public {} function transfer() public {}

Solution

1. Step 1: Check function names and parameters

   Both functions are named 'transfer' but have different parameter lists (one with uint, one with address and uint).

2. Step 2: Confirm this matches overloading rules

   Overloading requires same name but different inputs, which function transfer(uint amount) public {} function transfer(address to, uint amount) public {} shows correctly.

3. Final Answer:

   function transfer(uint amount) public {} function transfer(address to, uint amount) public {} -> Option A

4. Quick Check:

   Different inputs, same name = correct syntax [OK]

Hint: Different parameters, same name is correct overloading [OK]

Common Mistakes:

• Using same parameters for both functions
• Changing only visibility, not parameters
• Defining identical functions twice

3. Given the Solidity code:

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

What is the output of calculate(3) and calculate(3, 4)?

medium

A. 6 and 12

B. 3 and 7

C. 6 and 7

D. Compilation error

Solution

1. Step 1: Analyze the first function call calculate(3)

   This calls the function with one uint parameter, returning 3 * 2 = 6.

2. Step 2: Analyze the second function call calculate(3, 4)

   This calls the overloaded function with two uint parameters, returning 3 + 4 = 7.

3. Final Answer:

   6 and 7 -> Option C

4. Quick Check:

   Single input doubles, two inputs add [OK]

Hint: Match input count to correct function [OK]

Common Mistakes:

• Assuming both calls use the same function
• Mixing multiplication and addition results
• Expecting compilation error due to overloading

4. Identify the error in this Solidity contract using function overloading:

contract Test {
  function send(address to) public {}
  function send(address to) public {}
}

medium

A. Functions have the same name and parameters causing a duplicate definition error

B. Functions must have different visibility to overload

C. Function names must be unique in a contract

D. Functions must return a value to overload

Solution

1. Step 1: Check function names and parameters

   Both functions are named 'send' and have the exact same parameter list (address to).

2. Step 2: Understand overloading rules

   Overloading requires different parameters; identical signatures cause duplicate definition error.

3. Final Answer:

   Functions have the same name and parameters causing a duplicate definition error -> Option A

4. Quick Check:

   Same name and parameters = error [OK]

Hint: Overloaded functions must differ in parameters [OK]

Common Mistakes:

• Thinking visibility difference allows overloading
• Believing function return type affects overloading
• Assuming same name always allowed

5. You want to create a smart contract function deposit that accepts either a single uint amount or a uint amount with a string note. How would you overload the deposit function correctly?

hard

A. function deposit(uint amount) public {} function deposit(string memory note, uint amount) public {}

B. function deposit(uint amount) public {} function deposit() public {}

C. function deposit(uint amount) public {} function deposit(uint amount) public {}

D. function deposit(uint amount) public {} function deposit(uint amount, string memory note) public {}

Solution

1. Step 1: Define first function with single uint parameter

   The first deposit function takes only the amount as uint.

2. Step 2: Define second function with uint and string parameters

   The second deposit function adds a string note parameter after the uint amount.

3. Step 3: Confirm parameter order and types differ

   Both functions share the name but differ in parameter count and types, valid overloading.

4. Final Answer:

   function deposit(uint amount) public {} function deposit(uint amount, string memory note) public {} -> Option D

5. Quick Check:

   Same name, different parameters = correct overloading [OK]

Hint: Overload by changing parameter count or types [OK]

Common Mistakes:

• Swapping parameter order causing confusion
• Using identical parameter lists
• Omitting parameter types