Sidebar
This is an old revision of the document!
Table of Contents
2.3.4.8.4.5 Special Methods
Overview
Some Object-Oriented Programming (OOP) Languages have the ability to o 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, 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 which can be a problem during debugging and performance tuning.
DIDO Specifics
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:
- A
Countersmart contract is made (Line 4) - It defines an Unsigned Integer (
uint256) as a State Variable namedcounterand initializes it to zero. (Line 6)- Note: In Solidity, all Unsigned Integers are initialized to zero, but it is best to be explicit.
- The contract defines two methods that manipulate the value of
counter:- A
publicfunction namedincrementby one (Line 8) - A
publicfunction nameddecrementby one (Line 13)
Calling the SafeMath function to modify theunit256state variablecounter(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 contract1)Wikipedia, Operator overloading, Accessed: 4 November 2021, https://en.wikipedia.org/wiki/Operator_overloading2)OpenZeppelin.com, SafeMath, Accessed: 27 December 2021, https://docs.openzeppelin.com/contracts/2.x/api/math
dido/public/ra/1.2_views/3_taxonomic/4_data_tax/08_objects/07_opers/07_special.1640808377.txt.gz · Last modified: 2021/12/29 15:06 by nickTranslations of this page:
