Polimorfismo de Solidez

Neste artigo, veremos técnicas de polimorfismo de solidez que nos ajudarão a usar as funções de solidez de maneira eficiente.

O Solidity, assim como qualquer outra linguagem de programação, possui a capacidade de processar dados em múltiplas formas, o que é conhecido como polimorfismo .

Em particular, o Solidity permite dois tipos de polimorfismo:

Polimorfismo de funções.
Polimorfismo Contratual.

Em primeiro lugar, aprenderemos sobre o polimorfismo de funções.

Índice-

Polimorfismo de Solidez:
- Polimorfismo de Solidez - Função:
- Polimorfismo de contrato:

Polimorfismo de Solidez - Função

Sobrecarga de métodos, ou Polimorfismo de Função, é um recurso que permite declarar várias funções com o mesmo nome dentro de um contrato ou contrato herdado.

Duas funções com o mesmo nome podem ser sobrecarregadas alterando o número de parâmetros ou o tipo de dados dos parâmetros.

O exemplo a seguir mostra a função get_Sum() sendo sobrecarregada, alterando os tipos de dados de seus parâmetros:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
pragma solidity ^0.8.0;
contract SolidityTest{
   function get_Sum(uint mrx,uint ample) public pure returns(uint){
   return mrx+ample;
   }
   function get_Sum(int mrx,int ample) public pure returns(int){
   return mrx+ample;
   }
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Exemplo de Explicação

O exemplo acima é um contrato inteligente do Solidity que demonstra polimorfismo de função, especificamente sobrecarga de método.

O contrato é chamado “ SolidityTest ” e define duas funções com o mesmo nome, “ get_Sum “, mas com diferentes tipos de parâmetros de entrada ( uint e int ).

A primeira função recebe dois inteiros sem sinal (uint mrx e uint ample ) como entradas e retorna sua soma como um inteiro sem sinal (uint).

A segunda função recebe dois inteiros com sinal (int mrx e int ample) como entradas e retorna sua soma como um inteiro com sinal (int).

Isso significa que se um usuário chamar a função “get_Sum” com duas entradas uint, a primeira função será executada e retornará um resultado uint.

Por outro lado, se um usuário chamar a mesma função com duas entradas int, a segunda função será executada e retornará um resultado int.

Ao utilizar o polimorfismo da função dessa maneira, o contrato fornece uma interface mais flexível e conveniente para os usuários, pois eles podem chamar o mesmo nome de função com diferentes tipos de entrada, sem ter que se preocupar com os detalhes de implementação interna do contrato.

Da mesma forma, o mesmo processo de sobrecarga de função pode ser feito alterando o número de parâmetros da função conforme mostrado abaixo:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
pragma solidity ^0.8.0;
contract SolidityTest{
   function get_Sum(uint mrx,uint ample) public pure returns(uint){
   return mrx+ample;
   }
   function get_Sum(uint mrx,uint ample,uint mrx_ample) public pure returns(uint){
   return mrx+ample+mrx_ample;
   }
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Observação : se você achar difícil executar o código acima, consulte nosso primeiro artigo de aplicativo de solidity para obter mais entendimento.

Vamos passar para o segundo tipo de polimorfismo de solidez, que é o polimorfismo de contrato.

Polimorfismo Contratual

Refere-se à prática de utilizar várias instâncias de contratos relacionados de forma intercambiável por meio de herança.

Isso permite que funções de contrato filho sejam chamadas usando uma instância de contrato pai.

O exemplo a seguir nos ajudará a entender o polimorfismo do contrato:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
pragma solidity ^0.8.0;
contract SolidityTest{
  uint public mrx;
  uint public ample;
 
 
   function setValue(uint a,uint b) public {
 
   mrx=a;
   ample=b;
   }
   function getValue() public view returns(uint){
 
   uint product=mrx*ample;
   return product;
   }
}
contract SolidityTest1{
   uint mrx1;
   uint ample1;
   uint mrx1_ample1;
 
    function setValue(uint a,uint b,uint c) public {
 
   mrx1=a;
   ample1=b;
   mrx1_ample1=c;
   }
   function getValue() public view returns(uint){
 
   uint sum=mrx1+ample1+mrx1_ample1;
   return sum;
   }
}
contract SolidityTest2{
  SolidityTest obj1=new SolidityTest();
  SolidityTest1 obj2=new SolidityTest1();
function show_Both_Methods() public view returns(uint,uint){
uint pro=obj1.getValue();
uint add=obj2.getValue();
 
 
return(pro,add);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Conclusão

O polimorfismo de solidez é considerado uma ferramenta eficiente quando se trata de qualquer linguagem de programação.

Este processo não apenas nos ajuda a usar nossas funções de forma eficiente, mas também nos ajuda a usar algumas linhas de código por causa de sua técnica de funções de sobrecarga de método e sobrecarga de contrato.

Nós valorizamos o seu feedback.

Polimorfismo de Solidez

Polimorfismo de Solidez - Função

Example:

Exemplo de Explicação

Example:

Polimorfismo Contratual

Example:

Conclusão

Sentindo entediado?