What is Function Overloading?

Function overloading in Solidity allows you to define multiple functions with the same name but different parameter lists within the same contract. This feature improves readability, usability, and code reusability.

---

Rules for Function Overloading in Solidity

When implementing function overloading, you must follow these rules:

1. Same function name → Overloaded functions must have the same name.
2. Different parameter list → Functions must differ in the number, types, or order of their parameters.
   • Example: one function accepts two uint values, another accepts three.
   • Example: one function accepts int, another accepts uint.
   • Example: one function accepts (string, uint), another accepts (uint, string).
3. Return type does not matter → You cannot rely on return type alone to distinguish overloaded functions.
4. Visibility does not affect overloading → public, private, internal, and external do not influence overloading.
5. State mutability does not affect overloading → pure, view, payable, etc., do not affect function overloading.

---

Example: Function Overloading in Solidity

pragma solidity ^0.8.0;

contract FunctionOverloadingExample {
    // Example 1: Different number of parameters
    function add(uint a, uint b) public pure returns (uint) {
        return a + b;
    }
    function add(uint a, uint b, uint c) public pure returns (uint) {
        return a + b + c;
    }

    // Example 2: Different parameter types
    function multiply(int a, int b) public pure returns (int) {
        return a * b;
    }
    function multiply(uint a, uint b) public pure returns (uint) {
        return a * b;
    }

    // Example 3: Different parameter order
    function concatenate(string memory a, uint b) public pure returns (string memory) {
        return string(abi.encodePacked(a, uint2str(b)));
    }
    function concatenate(uint a, string memory b) public pure returns (string memory) {
        return string(abi.encodePacked(uint2str(a), b));
    }

    // Helper function: convert uint to string
    function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len;
        while (_i != 0) {
            k--;
            uint8 temp = uint8(48 + _i % 10);
            bstr[k] = bytes1(temp);
            _i /= 10;
        }
        return string(bstr);
    }
}

---

Explanation of the Example

• add function → Overloaded by changing the number of parameters (add(uint,uint) vs add(uint,uint,uint)).
• multiply function → Overloaded by changing parameter types (multiply(int,int) vs multiply(uint,uint)).
• concatenate function → Overloaded by changing the order of parameters ((string,uint) vs (uint,string)).

---

Summary

• Function overloading allows multiple functions with the same name but different parameter lists.
• The number, type, or order of parameters must be different.
• Return type, visibility, and mutability do not affect overloading.
• Overloading makes contracts more flexible, readable, and reusable.