Code . Bitacoras . Com

Detalles Aprendidos en un Examen

Si quisieramos hacer una copia de un objeto no es necesario, ir atributo por atributo.
self.nombre:=obj.getNombre;
self.edad:=obj.getEdad;
pudiendose hacer directamente
self:=obj;

Al estar en una Unidad, por ejemplo TPersona, no se pueden hacer cosas como:
self.nombre:=objP.nombre //pese a que objP sea TPersona.
sino, self.nombre:=objP.getNombre // puesto que no es objP el objeto en curso, y para acceder a sus atributos usaremos consultores o modificadores, depende del caso.

Final

Ander Aqui tienes todo colgado, espero que te sirva de ayuda.
//////////////////////////////////////////////////////////////////////////////////
unit uCliente;
////////////////////////////////////////////////////////////////////////////////
// CLASE: Cliente //
// Atributos: codigo, nombre, numEmpastes //
// Metodos Extra: PedirDatos, MostrarDatos //
// Metodos: Constructores, Consultores, Modificadores, Destructor //
////////////////////////////////////////////////////////////////////////////////

interface
type
TCliente=class
private
codigo:integer;
nombre:string[100];
numEmpastes:integer;

public
constructor Create();overload;
constructor Create(cod:integer;nom:string;numE:integer);overload;

function getCodigo():integer;
function getNombre():string;
function getNumEmpastes():integer;

procedure setCodigo(cod:integer);
procedure setNombre(nom:string);
procedure setNumEmpastes(numE:integer);

procedure pedirDatos();
procedure mostrarDatos();

destructor Destroy();
end;

implementation
constructor TCliente.Create();
begin
self.codigo:=0; self.nombre:=' '; self.numEmpastes:=0;
end;

constructor TCliente.Create(cod:integer;nom:string;numE:integer);
begin
self.codigo:=cod;
self.nombre:=nom;
self.numEmpastes:=numE;
end;

function TCliente.getCodigo():integer;
begin
result:=codigo;
end;

function TCliente.getNombre():string;
begin
result:=nombre;
end;

function TCliente.getNumEmpastes():integer;
begin
result:=numEmpastes;
end;

procedure TCliente.setCodigo(cod:integer);
begin
self.codigo:=cod;
end;

procedure TCliente.setNombre(nom:string);
begin
self.nombre:=nom;
end;

procedure TCliente.setNumEmpastes(numE:integer);
begin
self.numEmpastes:=numE;
end;

procedure TCliente.pedirDatos();
begin
write('Introduce el Codigo:');
readln(self.codigo);
write('Introduce el Nombre y los Apellidos:');
readln(self.nombre);
write('Introduce el numero de Empastes:');
readln(self.numEmpastes);
end;

procedure TCliente.mostrarDatos();
begin
writeln('CODIGO:',self.codigo);
writeln('NOMBRE APELLIDOS:',self.nombre);
writeln('NUM EMPASTES:',self.numEmpastes);
writeln('');
end;

destructor TCliente.Destroy();
begin
inherited destroy;
end;
end.

//
nterface
uses uCliente;
type
TVector=array[1..200]of TCliente;
TContenedor=class
private
vector:TVector;
numClientes:integer;
public
constructor Create();overload;
constructor Create(vector:TVector;numClientes:integer);overload;

function getNumClientes():integer;
procedure setNumClientes(client:integer);

function Buscar(codigo:integer):integer;
function Obtener(posicion:integer):TCliente;
procedure Borrar(codigo:integer);
procedure Anyadir(obj:TCliente);
function Tamanyo():integer;

end;

implementation
constructor TContenedor.Create();
var i:integer;
begin
for i:=1 to 200 do
self.vector[i]:=TCliente.create;
self.numClientes:=0;
end;

constructor TContenedor.Create(vector:TVector;numClientes:integer);
var i:integer;
begin
for i:=1 to 200 do
begin
self.vector[i]:=TCliente.create;
end;
self.numClientes:=numClientes;
end;

function TContenedor.getNumClientes():integer;
begin
result:=numClientes;
end;

procedure TContenedor.setNumClientes(client:integer);
begin
self.numClientes:=client;
end;

function TContenedor.buscar(codigo:integer):integer;
var
i:integer;
begin
i:=1;
result:=-1;
while (result<>i)and (i<=self.NumClientes) do
begin
if (self.vector[i].getCodigo = codigo) then //buscar
result:=i
else i:=i+1;

end;
end;
//////////
function TContenedor.Obtener(posicion:integer):TCliente;
begin
result:=self.vector[posicion]
end;
procedure TContenedor.Borrar(codigo:integer);
var i:integer;
begin
i:=buscar(codigo);//posicion
while(i<(self.NumClientes)) do
begin
self.vector[i].setCodigo(vector[i+1].getCodigo);
self.vector[i].setNombre(vector[i+1].getNombre);
self.vector[i].setNumEmpastes(vector[i+1].getNumEmpastes);
i:=i+1;
end;
self.vector[i].Create();
self.NumClientes:=NumClientes-1;
end;

procedure TContenedor.Anyadir(obj:TCliente); //inserta de menor a mayor en Array
var i,j:integer; enc:boolean;
begin
i:=NumClientes; enc:=false;
while(not(enc)) do
begin
if ((self.vector[i].getCodigo)<(obj.getCodigo)) then //condicion de que sea menor CODE
begin
for j:=self.NumClientes downto i+1 do
begin
self.vector[j+1].setNombre(vector[j].getNombre);
self.vector[j+1].setCodigo(vector[j].getCodigo);
self.vector[j+1].setNumEmpastes(vector[j].getNumEmpastes);
end;
vector[i+1].setNombre(obj.getNombre); //TContenedor[Tclientes]
vector[i+1].setCodigo(obj.getCodigo);
vector[i+1].setNumEmpastes(obj.getNumEmpastes);
NumClientes:=NumClientes+1; enc:=true;
end
else
begin
i:=i-1;
if (NumClientes=0) then //primer elemento
begin
vector[1].setNombre(obj.getNombre); //TContenedor[Tclientes]
vector[1].setCodigo(obj.getCodigo);
vector[1].setNumEmpastes(obj.getNumEmpastes);
NumClientes:=NumClientes+1; enc:=true;
end;
end;

end;
i:=i-1;
end;
//write('Ya hay un numero maximo de 200 clientes');

function TContenedor.Tamanyo():integer;
begin
result:=NumClientes;
end;

end.
////////////

{$APPTYPE CONSOLE}

uses
SysUtils,
UCliente,
UContenedor,
UFichero;
////////////////////////////////////////////////////////////////////////////////
procedure Cls();
var i:integer;
begin
for i:=1 to 25 do
writeln(' ');
end;
procedure PulseEnter();
begin
writeln;
write('Pulsa INTRO para continuar ...');
writeln; readln;
end;
////////////////////////////////////////////////////////////////////////////////

procedure NuevoCliente(var deposito:TContenedor;var objC:TCliente);
var
//objC:TCliente;
insertado:boolean;
begin
writeln('Nuevo Cliente');
writeln('=============');
insertado:=false;
objC.pedirDatos();
while not (insertado) do
begin
if deposito.Buscar(objC.getCodigo)=-1 then// devuelve -1 sino existe; sino la posicion
begin
deposito.Anyadir(objC);
insertado:=true;
end
else
begin
writeln('Error el codigo que deseas introducir ya existe');
ObjC.PedirDatos();
end;//DEL else
end;//DEL WHILE
end;//DEL procedure
//////////////////////////////////////////////
procedure EliminarCliente(var deposito:TContenedor);
var
eliminado:boolean;
code:integer;
begin
write('Introduce el codigo que deseas eliminar:');
readln(code);
eliminado:=false;
while not(eliminado) do
begin
if not(deposito.Buscar(code)=-1) then //-1 si no existe
begin
deposito.borrar(code);
eliminado:=true;
end
else //el codigo no existe y no se puede eliminar
begin
end;


end;
end;
//////////////////////////////////////////////////
procedure VisualizarCliente(var deposito:TContenedor);
var i:integer;
begin
for i:=1 to deposito.Tamanyo do
begin
if (i mod 3)<>0 then
deposito.obtener(i).MostrarDatos()
else
begin
deposito.obtener(i).MostrarDatos();
PulseEnter();cls();
end;
end;
if not(deposito.Tamanyo mod 3 = 0)then //Si no es multiplo de 3
PulseEnter();
end;
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
procedure MostrarMenu(var opc:char; var contenedor:TContenedor;obj:TCliente);
procedure SelectMenu(var opc:char);
procedure ProcesarMenu(var opc:char);
begin
cls();
case opc of
'1':NuevoCliente(contenedor,obj);
'2':EliminarCliente(contenedor);
'3':VisualizarCliente(contenedor);
end;
end;
begin
write('Elige tu opcion:');
readln(opc);
while (opc <'1') or (opc >'4') do
begin
writeln('ERROR!!! introduce un valor entre 1..4');
write('Elige tu Opcion:');
readln(opc);
end;
ProcesarMenu(opc);
end;
begin
writeln('MEDIC4L_GEST');
writeln('^^^^^^^^^^^^');
writeln;
writeln(' 1.-Nuevo Cliente');
writeln(' 2.-Eliminar Cliente');
writeln(' 3.-Visualizar');
writeln;
writeln(' 4.-Salir');
writeln;
SelectMenu(opc);
end;

////////////////////////////////////////////////////////////////////////////////

//Programa Principal/////
var
contenedor : TContenedor; opc:char; obj:TCliente;

begin
obj:=TCliente.Create();
contenedor := TContenedor.create;
cargarArray(contenedor);
//
repeat
cls(); //
MostrarMenu(opc,contenedor,obj);
until(opc='4');
// Aquí irá el programa principal, como véis, el contenedor ya está creado
// y toda la parte de gestión de ficheros está hecha, así que olvidaros de ella.

guardarArray(contenedor);
end

Ejercicio CAST Animales

program Herencia_polimorfismo;

{$APPTYPE CONSOLE}

uses
SysUtils, UAnimal, UAereo, UAcuatico, UTerrestre;

var
animal : TAnimal;
vaca : TTerrestre;


begin
{ TODO -oUser -cConsole Main : GPL CoDe }
{instanciar el objeto Terrestre
4patas
sinPico
Pelos
Europa
Herbivoro}
vaca:=TTerrestre.Create(4,false,pelos,Europa,Herbivoro);
writeln(vaca.getPico);
writeln(vaca.getnMiembros);
//writeln(vaca.setPelaje(escamas)); //Como le paso los parametros de la clase padre?
{fallal getPelaje
{al metodo saludar de la vaca}
vaca.saludar;

{Apuntar al objeto referenciado por vaca, desde la referencia de tipo
TAnimal que se llama .animal. Es decir, aqui hay que hacer una asignacion
de la vaca al animal}
animal:=vaca;
animal.saludar;
{######### mod (ii) ##############}
{si no estuviera redefinido (unidad sin override) en la clase TTerrestre
{sale el saludo de cada clase}
{asi ;animal.saludar; muestra: "Hola, soy un animalito:-)"}
{#################################}

{########## mod (iii) ############}
{el error en .animal.comer;. se debe a que comer; es un procedimiento abstracto
de UAnimal, asi es imposible invocar a un objTAnimal.comer;. Los metodos abstractos
no se implementan en el padre, sino en las clase hijas}

//vaca.comer;
//animal.comer;
{################################}

readln;

end.

unit UAnimal;

interface
type TPelaje = (pelos,escamas,plumas);
type TAnimal = class
{Se trata da una class abstracta puesto que posee al menos
un metodo abstracto, en este caso, COMER}
protected
nMiembros:integer;
pico:boolean;
pelaje:TPelaje;//definir tipo TPelaje = (pelos, escamas, plumas);
//**************************************************************
public
Constructor Create(nMiembro:integer; pic:boolean; p:TPelaje);

function getnMiembros():integer;
function getPico():boolean;
function getPelaje():TPelaje;

procedure setnMiembros(nMiembro:integer);
procedure setPico(pic:boolean);
procedure setPelaje(p:TPelaje);

procedure comer();virtual; abstract;{TAnimal no posee Comer, si sus hijas}
{porque tiene que ser virtual y abstracto y no sólo abstracto?}
procedure saludar();virtual; //virtual
end;
//**************************************************************

implementation
constructor TAnimal.Create(nMiembro:integer; pic:boolean; p:TPelaje);
begin
nMiembros:=nMiembro;
pico:=pic;
pelaje:=p;
end;

function TAnimal.getnMiembros():integer;
begin
result:=nMiembros;
end;

function TAnimal.getPico():boolean;
begin
result:=pico;
end;

function TAnimal.getPelaje():TPelaje;
begin
result:=pelaje;
end;


procedure TAnimal.setnMiembros(nMiembro:integer);
begin
nMiembros:=nMiembro;
end;

procedure TAnimal.setPico(pic:boolean);
begin
pico:=pic;
end;

procedure TAnimal.setPelaje(p:TPelaje);
begin
pelaje:=p;
end;

procedure TAnimal.saludar();
begin
write('Hola, soy un animalito ;-) ');
end;
end.
//////////////////////////////////////////////////
unit UAcuatico;

interface
uses
UAnimal;
type TAcuatico = class (TAnimal)
private
TieneDientes : boolean;
TieneAgallas : boolean;

public
constructor Create(tDientes:boolean; tAgallas:boolean);

function getTieneDientes():boolean;
function getTieneAgallas():boolean;

procedure setTieneDientes(tDientes:boolean);
procedure setTieneAgallas(tAgallas:boolean);

procedure saludar; override;
procedure comer;

end;

implementation
constructor TAcuatico.Create(tDientes:boolean; tAgallas:boolean);
begin
TieneDientes:=tDientes;
TieneAgallas:=tAgallas;
end;

function TAcuatico.getTieneDientes():boolean;
begin
result:=TieneDientes;
end;

function TAcuatico.getTieneAgallas():boolean;
begin
result:=TieneAgallas;
end;

procedure TAcuatico.setTieneDientes(tDientes:boolean);
begin
TieneDientes:=tDientes;
end;

procedure TAcuatico.setTieneAgallas(tAgallas:boolean);
begin
TieneAgallas:=tAgallas;
end;

procedure Tacuatico.Saludar();
begin
write('Hola, soy un animal acuatico');
end;

procedure TAcuatico.comer();
begin
write('Como soy un animal acuatico, me alimento de pescaditos');
end;



end.
/////////////////////////////////////////////
unit UAereo;

interface
uses
UAnimal;

type TAereo = class (TAnimal)

private //or protected
volador : boolean;
colorPlumaje : string;

public
constructor create(vol:boolean; cPlumaje:string);

function getVolador():boolean;
function getcolorPlumaje():string;

procedure setVolador(vol:boolean);
procedure setcolorPlumaje(cPlumaje:string);

procedure saludar; override;
procedure comer;

end;

implementation
constructor TAereo.Create(vol:boolean; cPlumaje:string);
begin
volador:=vol;
colorPlumaje:=cPlumaje;
end;

function TAereo.getVolador():boolean;
begin
result:=volador;
end;

function TAereo.getcolorPlumaje():string;
begin
result:=colorPlumaje;
end;

procedure TAereo.setVolador(vol:boolean);
begin
volador:=vol;
end;

procedure TAereo.setcolorPlumaje(cPlumaje:string);
begin
colorPlumaje:=cPlumaje;
end;

procedure TAereo.saludar;
begin
write('Hola, soy un animal aereo');
end;

procedure TAereo.comer;
begin
write('Como soy un animal aereo, me alimento de insectos');
end;

end.
/////////////////////////////////
unit UTerrestre;

interface
uses
UAnimal;

type TContinente = (Europa,Asia,Africa,Oceania,America);
type TDieta = (Herbivoro,Carnivoro,Omnivoro);

type TTerrestre = class (TAnimal)
private {protected or}
Continente:TContinente;
Dieta:TDieta;

public
constructor Create (nMiembro:integer; pic:boolean; p:TPelaje; cont:TContinente; diet:TDieta);

function getContinente():TContinente;
function getDieta():TDieta;

procedure setContinente(cont:TContinente);
procedure setDieta(diet:TDieta);

procedure saludar;override; {redefinicion-override}
procedure comer; //implementado por 1 vez

end;

implementation
constructor TTerrestre.Create(nMiembro:integer; pic:boolean; p:TPelaje; cont:TContinente; diet:TDieta);
begin //atencion invocar metodos de la clase padre!
{hay 2 formas de hacerlo}
{variante 1}
inherited Create(nMiembro, pic, p);
{variante-2}
{nMiembros:=nMiembro; pico:=pic; pelaje:=p;}
Continente:=cont;
Dieta:=diet;
end;

function TTerrestre.getContinente():TContinente;
begin
result:=continente;
end;

function TTerrestre.getDieta():TDieta;
begin
result:=dieta;
end;

procedure TTerrestre.setContinente(cont:TContinente);
begin
Continente:=cont;
end;

procedure TTerrestre.setDieta(diet:TDieta);
begin
Dieta:=diet;
end;

procedure TTerrestre.Saludar();
begin
writeln('Hola, soy un animal terrestre ');
end;

procedure TTerrestre.comer();
begin
write('Como soy un animal Terrestre tengo una dieta, y en este caso es');
case (Dieta) of
Herbivoro: write(' Herbivoro');
Carnivoro: write(' Carnivoro');
Omnivoro: write(' Omnivoro');
end;
//write('Como soy un animal Terrestre tengo una dieta, y en este caso es');
end;

end.

Ejercicio Horas

Aqui esta el ejercicio de las Horas.

program ejercicio2;



{$APPTYPE CONSOLE}



uses

  SysUtils,

  uHora;

procedure PedirHora(var obj:THora);

var

hora,min,seg:integer;

begin

        writeln('Creacion');

        write('Introduce la hora:');

        readln(hora);

        write('Introduce los minutos:');

        readln(min);

        write('Introduce los segundos:');

        readln(seg);

        obj.setHora(hora);

        obj.setMin(min);

        obj.setSeg(seg);



end;

var

        obj1,obj2:THora;

begin

  { TODO -oUser -cConsole Main : Insert code here }

  obj1:=THora.Create;

  obj2:=THora.Create;

  PedirHora(obj1);

  PedirHora(obj2);

  writeln;

  write(' hora 1:  ');obj1.Visualizar;

  writeln;

  write(' hora 2:  ');obj2.Visualizar;

  if obj1.Comprobar(obj2.getHora,obj2.getMin,obj2.getSeg)=1 then

        begin

        writeln('La PRIMERA hora introducida es mayor');end

        else begin

                writeln('La SEGUNDA hora introducida es mayor');

        end;



        writeln('Desde la media noche pasaron ',obj1.MediaNoche(),' seg');

        writeln('Desde la media noche pasaron ',obj2.MediaNoche(),' seg');

        writeln(obj2.ConvertirAHora((obj2.MediaNoche())));

        writeln;

        write(' SUMA DE HORAS:   ');

        obj1.Sumar(obj2);

        obj1.Visualizar; writeln;//la suma no modifica

        writeln('La suma de horas, pasaron desde la media noche ',obj1.MediaNoche(),' seg');

  readln;

end.

Y Aqui la Unidad

unit uHora;



interface

        type THora=class

                private

                hora:integer;

                min:integer;

                seg:integer;



                public

                constructor Create();overload;

                constructor Create(h,m,s:integer);overload;



                function getHora():integer;

                function getMin():integer;

                function getSeg():integer;



                procedure setHora(h:integer);

                procedure setMin(m:integer);

                procedure setSeg(s:integer);



                procedure Visualizar();

                procedure Sumar(obj:THora);

                function Comprobar(h,m,s:integer):integer;

                function MediaNoche():integer;

                function ConvertirAHora(numero:integer):integer;





                destructor Destroy();

                end;



implementation

        constructor THora.Create();

        begin

        hora:=0; min:=0; seg:=0;

        end;



        constructor THora.Create(h,m,s:integer);

        begin

        hora:=h; min:=m; seg:=s;

        end;



        function THora.getHora():integer;

        begin

                result:=hora;

        end;



        function THora.getMin():integer;

        begin

                result:=min;

        end;



        function THora.getSeg():integer;

        begin

                result:=seg;

        end;



        procedure THora.setHora(h:integer);

        begin

                hora:=h;

        end;



        procedure THora.setMin(m:integer);

        begin

                min:=m;

        end;



        procedure THora.setSeg(s:integer);

        begin

                seg:=s;

        end;



        procedure THora.Visualizar();

        begin

                write(hora,':',min,':',seg);

        end;



        procedure THora.Sumar(obj:THora);

        begin

        seg:=obj.seg+seg;

        if(seg>59) then

                begin

                seg:=seg-60;

                min:=min+1;

                end;

        min:=obj.min+min;

        if(min>59)then

                begin

                min:=min-60;

                hora:=hora+1;

                end;

        hora:=obj.hora+hora;

        if (hora>23) then

                begin

                hora:=hora-24;

                end;

                

        end;



        function THora.Comprobar(h,m,s:integer):integer;

        begin

        if (hora>h)then //el del obj mayor

                begin

                result:=1;

                end

        else begin

                if (min>m) then

                        begin

                        result:=1;

                        end

                        else begin

                                if(seg>s)then

                                        begin

                                        result:=1;

                                        end

                                else if(seg<>s)or(min<>m)or(hora<>h)then

                                begin

                                result:=0;

                                end;

                        end;

                end;

        end;



        function THora.MediaNoche():integer;

        begin

        result:=(hora*60*60)+(min*60)+(seg);

        end;

        function THora.ConvertirAHora(numero:integer):integer;

        begin

                write(numero div (60*60));//horas

                numero:=(numero mod(60*60));

                write(':',numero div 60,':');

                result:=(numero mod 60)

        end;



        Destructor Thora.Destroy();

        begin

                inherited destroy;

        end;



end.

Espero que te sirva de ayuda, aunque aqui no hay nada de Casting ni clases padre.

Felicidades en C?

#include 



/*  gcc -o christmas christmas.c      */



main(t,_,a) char *a; { return!0
main(-86,0,a+1)+a)):1,t<_?main(t+1,_,a):3,main(-94,-27+t,a)&&t==2?_<13?

main(2,_+1,"%s %d %d\n"):9:16:t<0?t<-72?main(_,t,

"@n'+,#'/*{}w+/w#cdnr/+,{}r/*de}+,/*{*+,/w{%+,/w#q#n+,/#{l+,/n{n+,/+#n+,/#\

;#q#n+,/+k#;*+,/'r :'d*'3,}{w+K w'K:'+}e#';dq#'l \

q#'+d'K#!/+k#;q#'r}eKK#}w'r}eKK{nl]'/#;#q#n'){)#}w'){){nl]'/+#n';d}rw' i;# \

){nl]!/n{n#'; r{#w'r nc{nl]'/#{l,+'K {rw' iK{;[{nl]'/w#q#n'wk nw' \

iwk{KK{nl]!/w{%'l##w#' i; :{nl]'/*{q#'ld;r'}{nlwb!/*de}'c \

;;{nl'-{}rw]'/+,}##'*}#nc,',#nw]'/+kd'+e}+;#'rdq#w! nr'/ ') }+}{rl#'{n' ')#\

}'+}##(!!/"):t<-50?_==*a?putchar(31[a]):main(-65,_,a+1):

main((*a=='/')+t,_,a+1):0
"!ek;dc i@bK'(q)-[w]*%n+r3#l,{}:\nuwloca-O;m .vpbks,fxntdCeghiry"),a+1); }