[[Delphius]]

Hola Paulao,
"Hablas" bastante bien el español, no puedo decir lo mismo a la inversa. No se portugués por lo que si algunas palabras que digo no se me entienden avisame por favor.

Entiendo tu preocupación. Y puede que te sea de ayuda. Antes que nada quisiera sacarme una pequeña duda, ¿A que te refieres con que no puedes emplear el operador *?

Si me preguntas por el tema de la clases, yo sólo veo una. Una clase calculadora que posee los métodos:
SetOperando1
SetOperando2

GetOperando1
GetOperando2

Aunque no se si tuviera sentido estos Get. Habría que considerar si se desea tener una calculadora "con Memoria".

SetOperacion
GetResultado

También puede ser útil tener un Método
Clear. Que vendría a ser la famosa tecla C.

Volviendo al tema de la "Memoria", si se desea guardar algún valor para operar, tal vez un SetM, haciendo cierta analogía con la famosa tecla M.

No se que tan elaborada debe ser la clase que realices. Si se busca recrear una calculadora de bolsillo.

Me gustaría saber como estás pensando o imaginando la clase. Si tu duda pasa sobre como declarar una clase, un ejemplo es como sigue:

Código Delphi [-]
TCalculadora = class
private
  // aqui viene la lista de campos y métodos privados
protected // no tiene utilidad en este caso
  // aqui la lista de los protegidos
public
  // aqui los públicos
published // tampoco tiene utilidad si se trata de una clase no de componente
end;

Un ejemplo más completo:

Código Delphi [-]
TCalculadora = class
private
  FOperando1, FOperando2: real;
  FOperador: TOperador;
  procedure SetOperando1(Value: real);
  function GetOperando1: real;
  ...
public
  property Operando1: real read GetOperando1 write SetOperando1;
  ...
end;

Y su implementación viene a ser algo así:

Código Delphi [-]
procedure TCalculadora.SetOperando1(Value: real);
begin
  if Value <> FOperando1
    then Foperando := Value;
end;

function TCalculadora.GetOperando1: real;
begin
  result := FOperando1;
end;

Pero el asunto es aquí que hacer y como implementar el "GetResultado". Una forma sencilla es esta:

Código Delphi [-]
function TCalculadora.GetResultado: real;
begin
  case Operador of
    opSuma: Result := ...
    opResta: Result := ...
    ....
  end;
end;

Pero he aquí que otra parte del problema radica en el manejo del estado interno de una calculadora. Y he squí que dependerá de que tan viable es llevar un control y manejo "real" de una calculadora. ¿A que me refiero con esto?

A que por lo general las calculadoras cuando ingresan un número o un operando se quedan en un estado de espera y pueden suceder muchas cosas aquí. Por ejemplo:

Cuando uno ingresa un número (SetOperando) la calculadora se queda esperando tres posibles eventos:
1. Que se sigan ingresando un número. Con lo que dicho Operando no fue terminado.
2. Si se presiona un operador, se confirma recién que el operando ha sido ingresado correctamente.
3. Si se presiona el "igual" se obtiene el valor del operando.

Y he aquí que en función del operador suministrado, la calculadora se queda esperando en otro estado:
1. Espera la orden del segundo operando.
2. Espera la orden igual.

¿Y si no se ha ingresado ningún operando, y se invoca a un operador? ¿Que sucede?

Por ello te quiero preguntar Paulao, que tanto se necesita controlar. ¿Debe ser algo simple? ¿Se busca recrear una calculadora de bolsillo?

No se si con esto te traigo más dudas que respuestas. Lo que pasa es que cuando se lleva un diseño POO lo primero a tener en cuenta es el grado de abstracción que se desea y fijar el límite de los requisitos.

Por lo pronto sería recomendable que me explicases a que se debe que no puedes emplear * ¿Te refieres a que debes hacerlo con sumas sucesivas?

Espero no haberte confundido más.

Saludos,