TOTVSTEC

Árvore de páginas

TLPP - LANGUAGE

Assim como em outras linguagens modernas, TLPP permite que uma aplicação estabeleça um comportamento particular para operações entre dois objetos.

Isso significa que tendo dois objetos, obj1 e obj2, por exemplo, pode-se realizar operações do tipo:
obj1 + obj2
obj1 - obj2
obj1 * obj2
obj1 / obj2
obj1 == obj2

Adicionalmente, também é possível oferecer uma string resultante quando um objeto for empregado em contexto textual, como, por exemplo, fazer um conout do objeto: conout(obj1).

A sintaxe de sobrecarga reserva a palavra OPERATOR para esse propósito, sendo antecedida de ADD, SUB, MULT, DIV, COMPARE ou TOSTRING, naturalmente conduzindo à uma das sobrecargas mencionadas acima.
Assim sendo, não é permitido que o nome do método seja iniciado com o prefixo "operator".



Sobrecarga.tlpp
#include "tlpp-core.th"

Class ComplexNumber
   public data a
   public data b
   public method new()
   public method create(parm1, parm2)
   public OPERATOR Add (parm1)
   public OPERATOR Sub(parm1)
   public OPERATOR Mult(parm1)
   public OPERATOR Div(parm1)
   public OPERATOR Compare(parm1)
   public OPERATOR ToString()
endclass

Method new() class ComplexNumber
Return self

Method create(parm1, parm2) class ComplexNumber
   self:a := parm1
   self:b := parm2
Return Self


// Esse será o método invocado ao executar a soma de objetos do tipo ComplexNumber
Operator Add(parm1) class ComplexNumber
   Local ret := ComplexNumber():New()
   ret:a := self:a + parm1:a
   ret:b := self:b + parm1:b
Return ret

Operator Sub(parm1) class ComplexNumber
   Local ret := ComplexNumber():New()
   ret:a := self:a - parm1:a
   ret:b := self:b - parm1:b
Return ret

Operator Mult(parm1) class ComplexNumber
   Local ret := ComplexNumber():New()
   ret:a := self:a * parm1:a - (self:b * parm1:b)
   ret:b := (self:a * parm1:b) + (self:b * parm1:a)
Return ret

Operator Div(parm1) class ComplexNumber

   Local conj := ComplexNumber():New()
   Local ret  := ComplexNumber():New()
   
   // Conjugado do denominador 
   conj:a :=   parm1:a 
   conj:b := - parm1:b

   // Multipica numerador e denominador pelo conjugado
   ret  := self * conj
   conj := parm1 * conj 


   // Divide o resultado da multiplicacao do numerador pela parte real do denominador 
   ret:a := ret:a / conj:a
   ret:b := ret:b / conj:a

Return ret

Operator Compare(parm1) class ComplexNumber
   
   If (self:a > parm1:a .OR. self:b > parm1:b)
      Return 1
   EndIf

   If (self:a < parm1:a .OR. self:b < parm1:b)
      Return -1
   EndIf

Return 0

Operator ToString() class ComplexNumber
Return cValtoChar(self:a) + " + " + cValToChar(self:b) + "i"

Function U_ComplexNumber()
   
   Local obj  := ComplexNumber():Create(1, 2)
   Local obj2 := ComplexNumber():Create(3, 4)
   Local objRet
   
   objRet := obj + obj2
   Conout(objRet)
   
   objRet := obj - obj2
   Conout(objRet)
   
   objRet := obj * obj2
   Conout(objRet)

   objRet := obj / obj2
   Conout(objRet)

   If (obj < obj2)
      conout("Eu vi que o primeiro objeto é menor do que o segundo")
   EndIf

Return

Resultado do Exemplo

4 + 6i
-2 + -2i
-5 + 10i
0.44 + 0.08i
Eu vi que o primeiro objeto é menor do que o segundo



  • Sem rótulos