SoloCodigo

Programación General => Pascal => Mensaje iniciado por: Ocean Soul en Martes 6 de Diciembre de 2005, 22:49

Título: Tdas Eficiencia En Uso De Momoria.
Publicado por: Ocean Soul en Martes 6 de Diciembre de 2005, 22:49
Código: Text
  1.  
  2. Unit tdaAlgo;
  3. Type
  4.   PtrArlgo=^Sth;
  5.   Sth=Record
  6.       A:Ta;
  7.       B:Tb;
  8.       …
  9.       End;
  10.   TAlgo=ptrAlgo;
  11.  
  12. Procedure CrearAlgo(VAR A:TALGO);
  13. Begin
  14.   A:=Nil;
  15. End;
  16.  
  17. Procedure CargarAlgo(var A:Talgo);
  18. Begin
  19.   NEW(A);
  20.   With A^ do
  21.   Begin
  22. …
  23. …
  24.     …
  25. End;
  26. End;
  27.  
  28.  

De esta se hace mas eficiente el uso de memoria, pues la asignación de memoria de esta estructura, solo se efectúa cuando se CargarAlgo(var A:algo), y no simplemente por declarar una variable A:TAlgo, en la cláusula VAR un programa que usa la unidad, que es lo que sucedería si no se usa un puntero. Esto es cierto, no? Pero… que pasa cuando…
Program UsetdaAlgo;
Uses tdaAlgo;
Type
   Archivo=file of TAlgo*;
Var
Arch:Archivo;

*Porque pascal permite cualquier tipo salvo un archivo... entonces que guarda en el archivo?? Supongo que lo que lo que esta guardado en la dirección de memoria de A. Entonces que pasa?????????
Título: Re: Tdas Eficiencia En Uso De Momoria.
Publicado por: Enko en Miércoles 7 de Diciembre de 2005, 00:03
Las variables tipo archivos son una especie de punteros!
cuando haces>
Assign(F, "direccion");
lo que haces es hacer que el puntero apunte hacia la direccion del disco duro donde se encuentra el primer byte del archivo.

lo mismo que lo tuyo pero encapsulado en un objeto
Código: Text
  1.  
  2. type
  3.   TObject = object
  4.   private
  5.      FValue: ^Integer;
  6.   public
  7.     procedure SetValue(const Value: Integer);
  8.     function GetValue: Integer;
  9.     constructor Create;
  10.     destructor Destroy;
  11.    end;
  12.  
  13. { TObject }
  14. constructor TObject.Create;
  15. begin
  16.    New(FValue);
  17. end;
  18.  
  19. destructor TObject.Destroy;
  20. begin
  21.    FValue := nil;
  22. end;
  23.  
  24. function TObject.GetValue: Integer;
  25. begin
  26.    GetValue := FValue^;
  27. end;
  28.  
  29. procedure TObject.SetValue(const Value: Integer);
  30. begin
  31.     FValue^ := Value;
  32. end;
  33.  
  34. var
  35.   Item: TObject;
  36.  
  37. begin
  38.    Item.Create;
  39.    Item.SetValue(5);
  40.  
  41.    Write(Item.GetValue);
  42.    Item.Destroy;
  43.    ReadLn;
  44. end.
  45.  
  46.  

Abajo lo mismo pero encapsulado con POO en Delphi (m'as bonito)
Código: Text
  1.  
  2. type
  3.   TObject = class
  4.   private
  5.     FValue: ^Integer;
  6.     procedure SetValue(const Value: Integer);
  7.     function GetValue: Integer;
  8.   public
  9.     property Value: Integer read GetValue write SetValue;
  10.     constructor Create;
  11.     destructor Destroy;
  12.    end;
  13.  
  14. { TObject }
  15. constructor TObject.Create;
  16. begin
  17.   New(FValue);
  18. end;
  19.  
  20. destructor TObject.Destroy;
  21. begin
  22.    FValue := nil;
  23. end;
  24.  
  25. function TObject.GetValue: Integer;
  26. begin
  27.    GetValue := FValue^;
  28. end;
  29.  
  30. procedure TObject.SetValue(const Value: Integer);
  31. begin
  32.     FValue^ := Value;
  33. end;
  34.  
  35.  
  36. var
  37.   Item: TObject;
  38.  
  39. begin
  40.    Item := TObject.Create;
  41.    Item.Value := 5;
  42.  
  43.    Write(Item.Value);
  44.    ReadLn;
  45. end.
  46.  
  47.