BotonMenu
BotonIndice

Visita : http://www.conoce3000.com
Paypal : https://www.paypal.me/conoce3000/1

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL


10. INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS I.
10.8. PARAMETROS OPCIONALES Y USO DE SELF.
10. INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS I.
10.8. PARAMETROS OPCIONALES Y USO DE SELF.
10. INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS I.
10.8. PARAMETROS OPCIONALES Y USO DE SELF.

SIGUIENTE

SIGUIENTE

SIGUIENTE


‒ Parametros opcionales y uso de self.

Los parámetros opcionales, son una característica que también se puede usar con los procedimientos y funciones, siempre y cuando se incluya la directiva {$mode objfpc}.

Los parámetros opcionales en este capítulo se explicarán con métodos. Los parámetros opcionales nos permiten crear métodos en donde a un parámetro se le puede dar un valor predeterminado, para después usar el método con o sin el parámetro, ya que este parámetro es opcional. Para colocar un parámetro opcional este se debe colocar al final de la lista de parámetros, y colocar un valor después de la definición del tipo de dato con el símbolo igual. Ejemplo:

   TClase=Class
     Procedure MetodoA(var a:integer, b:integer=5)
   End;

Los parámetros opcionales no pueden ser parámetros por referencia (var), En este ejemplo el métodoA, se puede usar del siguiente modo:

   Objeto.MetodoA(b);

ó

   Objeto.MetodoA(b,7);

Cuando se usan métodos con más de un parámetro opcional, no se pueden saltar algunos parámetros. Es decir si se define el siguiente método:

   TClase=Class      Procedure Metodo(var a:integer; B:integer=1; c:char='x')    End;

Lo siguiente generará un error de compilación:

   Objeto.Metodo(b,,'f');

Cuando se usen parámetros opcionales con métodos sobrecargados es importante no hacer métodos ambiguos, por ejemplo considera la siguiente definición de métodos:

   TClase=Class
     procedure Metodo(a:real; B:integer = 0);
     procedure Metodo(a:real);
   End;

El compilador compilará la clase y también permitirá la creación del objeto, pero cuando se intente usar el método:

   Objeto.Metodo(5)

El compilador avisará de la inusual situación, para que se hagan los cambios pertinentes.

Los parámetros opcionales se limitan a los tipos de datos Números Enteros, Booleanos, Caracteres, Reales, y el tipo de dato string. Los registros, Conjuntos, Enumerados, Subrangos, arreglos estáticos no están permitidos. En el caso de los punteros el único valor predeterminado que es posible asignar es nil.

En el caso de los tipos de datos Pchar, PwideChar, AnsiString y UnicodeString estos se comportan como el tipo de dato string.

En el caso de un arreglo dinámico, este debe definirse como un tipo de dato y usarlo como parámetro, pero sólo se le puede asignar como valor predeterminado nil, ya que se le considera como un puntero. Ejemplo:

   Type
     Tlista=array of integer;
     TClase=Class
         procedure Metodo(a:real; cad:ansistring='Hola';Lista:Tlista=nil);
     End;

Con respecto a los arreglos abiertos (open array), estos no se pueden usar como parámetros opcionales.

En las clases que hemos estado desarrollando TComplejo y TReal, se tiene el método ObtCad, este tiene un parámetro, que nos indica la cantidad de decimales con el que nos debe mostrar el número, este parámetro puede ser un parámetro opcional, en donde el método se cambiaría por:

   Function ObtCad(dec:integer=0):string;

Este cambio se debe hacer en ambas clases TReal y TComplejo.

Otro cambio que se puede hacer a la clase TComplejo, será sobrecargar el método cuadrado con uno sin parámetros, para ello se hará uso de la palabra reservada self. El nuevo método será:

   Procedure TComplejo.Cuadrado;
     Begin
        Multiplicacion(self)
     End;

Este método sobrecarga al ya existente, y nos permite elevar al cuadrado el número actual colocado en el objeto, a diferencia del otro que eleva al cuadrado un número colocado en su parámetro.

Para poder hacer este cambio, se hace uso de self, self es un parámetro oculto que es una referencia al objeto actual, todos los métodos tienen este parámetro. Debido a que una clase puede ser instanciado por varios objetos, como por Ejemplo:

     Var A,B,C : TComplejo

Cuando se use el método cuadrado, self será reemplazado por A,B y C. cuando se ejecute el programa.

A continuación, las clases TComplejo y TReal con los cambios indicados:


Descargar
{$codepage utf8}
{$mode objfpc}
Unit Complejos05;
Interface
Type
  TComplejo = class
    private
    ParteReal,ParteImag:double;
    public
    Constructor Crear(i:double); //Crea un imaginario puro
    Constructor Crear(r,i:double);
    Function ObtReal:double;
    Function ObtImag:double;
    Procedure PonReal(n:double);
    Procedure PonImag(n:double);
    Function ObtCad(dec:integer=0):string;
    Function PonCad(n:string):integer;
    Procedure Adicion(n:TComplejo);
    Procedure Multiplicacion(n:TComplejo);virtual;
    Procedure Cuadrado(n:TComplejo);
    Procedure Cuadrado;
  End;

Implementation

    Constructor TComplejo.Crear(i:double);
      Begin
        ParteReal:=0;
        ParteImag:=i
      End;

    Constructor TComplejo.Crear(r,i:double);
      Begin
        ParteReal:=r;
        ParteImag:=i;
      End;

    Function TComplejo.ObtReal:double;
      Begin
        ObtReal:=ParteReal
      End;

    Function TComplejo.ObtImag:double;
      Begin
        ObtImag:=ParteImag
      End;

    Procedure TComplejo.PonReal(n:double);
      Begin
        ParteReal:=n;
      End;

    Procedure TComplejo.PonImag(n:double);
      Begin
        ParteImag:=n
      End;

    Function TComplejo.ObtCad(dec:integer=0):string;
      var aux1,aux2,p:string;
      Begin
        p:='';
        Str(ParteReal:0:dec,aux1);
        Str(ParteImag:0:dec,aux2);
        if ParteImag>=0 then p:='+';
        ObtCad := aux1 + p +  aux2 + 'i';
      End;

      Function TComplejo.PonCad(n:string):integer;
      Var aux:string;
          p,i,error:integer;
          PR,PI:string;
          encontro:boolean;
      Begin
       aux:=n;
       ParteReal:=0;
       ParteImag:=0;
       error:=0;
       if (aux[length(aux)]='i') and (Not(aux[length(aux)-1]in['0'..'9']))
          then aux:=Copy(aux,1,length(aux)-1)+'1i';
       if aux[length(aux)]='i' then
         Begin
           delete(aux,length(aux),1);
           if aux[length(aux)] in ['0'..'9']
              then Begin
                     i:=length(aux);
                     encontro:=false;
                     p:=0;
                     while (not encontro) and (i>1) do
                      Begin
                       if (aux[i]='+') or (aux[i]='-')
                         then Begin
                               encontro:=true;
                               p:=i
                              end;
                       i:=i-1
                      End;
                     PR:=Copy(aux,1,p-1);
                     delete(aux,1,p-1);
                     PI:=aux;
                     Val(PR,ParteReal,error);
                     Val(PI,ParteImag,error);
                     if error<>0 then
                       Begin
                         ParteReal:=0;
                         ParteImag:=0
                       End
                   End;
         End
       else
        Begin
         Val(aux,ParteReal,error);
        End;
       PonCad:=error
      End;


    Procedure TComplejo.Adicion(n:TComplejo);
      Begin
        PonReal(ObtReal+n.ObtReal);
        PonImag(ObtImag+n.ObtImag)
      End;

    Procedure TComplejo.Multiplicacion(n:TComplejo);
      var PR,PI:double;
      Begin
       Writeln('Multiplicando con TComplejo');
       PR:=(ObtReal*n.ObtReal)-(ObtImag*n.ObtImag);
       PI:=(ObtReal*n.ObtImag)+(ObtImag*n.ObtReal);
       PonReal(PR);
       PonImag(PI)
      End;

    Procedure TComplejo.Cuadrado(n:Tcomplejo);
     Begin
       PonReal(n.obtReal);PonImag(n.ObtImag);
       Multiplicacion(n)
     End;

    Procedure TComplejo.Cuadrado;
     Begin
       Multiplicacion(self)
     End;
End.
Código fuente 24: Unidad Complejos con los métodos ObtCad con parametro opcional y el método Cuadrado con el uso de self.
Descargar


Descargar
{$codepage utf8}
{$mode objfpc}
Unit Reales05;
Interface
Uses Complejos05;
Type
TReal = class(TComplejo)
    Constructor Crear(r:double);
    Function ObtCad(dec:integer=0):string;
    Procedure Multiplicacion(n:TComplejo);override;
 End;

Implementation
    Constructor TReal.Crear(r:double);
      Begin
        inherited Crear(r,0);
      End;

    Function TReal.ObtCad(dec:integer=0):string;
      var p:string;
      Begin
         Str(ObtReal:0:dec,p);
         ObtCad := p
      End;

    Procedure TReal.Multiplicacion(n:TComplejo);
     Begin
       Writeln('Multiplicando con TReal');
       PonReal(ObtReal*n.ObtReal)
     End;

End.
Código fuente 25: Unidad Reales05 con el método ObtCad con parametro opcional.
Descargar




SIGUIENTE
SIGUIENTE
SIGUIENTE


 
‒ Comentarios y sugerencias.

Agradezco de antemano, todo comentario, sugerencia, y donativo (a través de Paypal me), que ayude a mejorar los contenidos educativos de Conoce 3000. Además, cualquier pregunta o duda que tengas lo puedes hacer por este medio. Pero, todo contenido que pueda resultar ofensivo, malicioso, racista, sexista, discriminatorio, obsceno, vulgar será eliminado.








PORTADA |  INTERESANTE |  APUNTES |  LIBROS |  GALERIA


Creative Commons License


Todos los textos, imágenes y videos de Conoce3000 estan colocados bajo una licencia : Creative Commons Reconocimiento-NoComercial 3.0 Unported License.