Some Object-Oriented Programming (OOP) Languages have the ability to overload built-in methods defined by the language. Some languages such as ALGOL, FORTRAN, R, and Scala allow all operators to be overwritten and even new operators to be defined. Others languages such as Ada, C#, C++, PHP, Python, Ruby, and Rust all a limited set of operators to be overwritten. C, Go, Java, JavaScript, and Visual Basic are examples that do not allow operators to be overwritten. 1)
Method Overloading, , sometimes termed Operator Overloading, or operator ad hoc polymorphism, is a specific case of polymorphism, where different operators have different implementations depending on their arguments. Operator overloading is generally defined by a programming language, a programmer, or both.
Operator Overloading is “syntactic sugar”, and is used because it allows programming using notation nearer to the target domain and allows user-defined types a similar level of syntactic support as types built into a language. It is common, for example, in scientific computing, where it allows computing representations of mathematical objects to be manipulated with the same syntax as on paper.
Operator overloading does not change the expressive power of a language (with functions), as it can be emulated using function calls. For example, consider variables a, b, c, d of some user-defined type, such as matrices:
Example 1:
matrix a, b, c, d; d = a + b * c;
In a language that supports operator overloading, and with the usual assumption that the '*' operator has higher precedence than the '+' operator, this is a concise way of writing:
Example 2:
matrix a, b, c, d; d = Add ( a, Multiply ( b, c ) );
However, the Example 1 syntax reflects common mathematical usage, but it can obfuscate the underlying fact that a, b, c, d are actually matrices that can be a problem during debugging and performance tuning.
Ethereum's Solidity does not support Operator Overloading directly, but it does support being able to create libraries of reusable functions that support a way to provide operators for specific types.
Probably the most well known example of reusable library is the SafeMath library2). In essence, the purpose of the SafeMath Library is to provide Overflow, Underflow, and Wrap Around protection while using Solidity's Unsigned Integer (uint).
The following classic Object-Oriented (OO) code example is written in Solidity. The Smart Contract does the following:
Counter smart contract is made (Line 4)uint256 ) as a State Variable named counter and initializes it to zero. (Line 6)
counter:
public function named increment by one (Line 8)public function named decrement by one (Line 13)unit256 state variable counter (Lines 10 and 15)
pragma solidity ^0.7.1;
// SPDX-License-Identifier: MIT
contract Counter
{ // Use SafeMath code
uint256 counter = 0;
function incrment()
public
{ counter = SafeMath.add ( counter, 1 );
} // End incrment function
function decrement()
public
{ counter = SafeMath.add ( counter, 1 );
} // End decrement function
} // End Counter contract
However, this code can have problems at the range edges of the uint256 type causing Overflow, Underflow, and Wrap Around issues. The original Counter Smart contract can be modified to check for the overflow or underflow issue every time the counter is manipulated, but in-line checking can create its own issues. For example, it introduces more lines of code and each line of code has the potential for being incorrect. A very classic error occurs when the code is copied and pasted from someplace else and all the references to the variable are not changed correctly.
A solution for these problems was introduced using an external library called SafeMath and the Solidity language using statement. By including this using SafeMath for <BaseType> at the beginning of the Smart Contract and replacing the traditional operators +, -, *, /, % with the following SafeMath defined functions: add, sub, mul, div and mod.
The Counter Smart Contract is modified to use SafeMath:
using for uint256 datatype statement is added (Line 5)unit256 state variable counter instead of using explicitly calling the SafeMath functions (Lines 10 and 15)
pragma solidity ^0.7.1;
// SPDX-License-Identifier: MIT
contract Counter
{ using SafeMath for uint256;
uint256 counter = 0;
function incrment()
public
{ counter = counter.add(1);
} // End incrment function
function decrement()
public
{ counter = counter.sub(1);
} // End incrment function
} // End Counter contract
Starting with Solidity 0.8 release, SafeMath is now integrated into the language and the import of the OpenZeppelin SafeMath is no longer needed. the standard mathematical operators (i.e., +, -, *, /, %) now use the SafeMath library. For Example:
a + b now automatically invokes revert on Overflow.
In the event that the Wrap Around behavior is the desired part of the design of the contract, the expression can be surrounded with the unchecked block. For example,
revert to ocur when SafeMath is used (Line 12)uint256 (i.e., 0) as initialized in Line 10, causes a Wrap Around returning a value of type(uint256).maxunchecked block (i.e., { and }) (Line 12)
pragma solidity ^0.8.1;
// SPDX-License-Identifier: MIT
contract MyContract
{
function test()
external
pure
returns(uint256)
{ uint256 x = 0;
unchecked { x--; }
return x;
} // End test function
} // End MyContract
[char]Review