23 respuestas en este tema

[Delphius]

Hola edorantes Para lograr un diseño como el que buscas:

delphi

MisUsuarios.Show(0).GetNombre;

Habría que hacer unos cuantos cambios.
A como lo tienes desarrollado no es posible llegar a esa forma. Considero que la forma más sencilla y que no te afecta demasiado a tu código es que además de ese Show le puedes declarar justamente los Getters que necesites. Y como dije: estos por necesidad deben recibir el índice. Es decir por ejemplo:

delphi

function TUsuarios.GetNombre(Indice: integer): string;
begin
  result := nombreU[Indice]; // o que es igual a result := nombreU.Strings[Indice];
end;

Hay una forma de llegar a un diseño como que deseas... pero para ello se debe ir a por lo último que te comenté: separar en dos clases: Una clase que mantenga la lista, la que llamé TUsuarios y otra la que hace a cada usuario: TUsuario.

Luego se puede añadir un método GetUsuario() a la clase TUsuarios que regrese el TUsuario correspondiente según el índice. Algo como:

delphi

function TUsuarios.GetUsuario(Indice: integer): TUsuario;
begin
  result := FLista.Items[Indice] as TUsuario; // o también result := TUsuario(FLista.Items[Indice]);
end;

Entonces cuando uno llama a ese método, recibe al objeto de la clase TUsuario correspondiente. Y como esta clase ya cuenta con métodos/propiedades para acceder a cada atributo es que entonces podemos hacer cosas como:

delphi

Edit2.Text := MisUsuarios.GetUsuario(5).Nombre;

En el ejemplo se GetUsuario devuelve al objeto que está 6to en la lista (recuerda que los índices en los TxxxList empiezan por 0 [cero]). Luego es que se accede a la propiedad Nombre.

Este diseño lleva a que se tenga que crear tantas instancias de TUsuario como se necesiten. Justamente se puede aprovechar a la clase TUsuarios para que asuma esta responsabilidad (ya que de paso se encarga de poner/sacar dicha lista), basta con añadirle un método que haga el trabajo. Algo como:

delphi

function TUsuarios.NewUsuario(ID: integer; SupCder, SupSder: Currency, Nombre, Cultivo: string): integer;
var User: TUsuario;
begin
  User := TUsuario.Create;
  User.ID := ID;
  User.Nombre := Nombre;
  User.SupCDer := SupCder;
  User.SupSder := SupSder;
  User.Cultivo := Cultivo;
  
  result := FLista.Add(TObject(User));
end;

Fíjate que aprovecho este método para no sólo ya crear el Usuario y llenarlo con la información necesaria sino que además, ya de paso lo agrego en la lista. Al ser una función el método regresa justamente el índice o posición.

Si se contase con este método ya no haría falta tener que estar creando por nuestros propios medios a los objetos de la clase Usuarios, ya le hemos dado la capacidad a TUsuarios.

Como notas finales:
1)En tu código que acabas de poner estás invocando a una clase y no a un objeto o instancia de ésta. Fíjate que estás haciendo:

delphi

Tusuarios.Show(0).getNombre

Cuando es:

delphi

var MisUsuarios: TUsuarios;
...
MisUsuarios.Show(0).getNombre;

Por algo recomiendo seguir la nomeclatura de Delphi. Se acostumbra a anteponer a nuestras clases el prefijo T, de modo que es TAlgo, para diferenciar de los nombres de los objetos de la misma. Por tanto:

TUsuarios >> Nombre de la clase
Usuarios >> Nombre de un objeto

2) Es IntToStr() y no IntToString.

Saludos,

[edorantes]

Gracias amigo ya quedo asi mira

delphi

unit uUsuarios;
 
interface
 
uses classes, Types, SysUtils, DM;
 
type
 
 //Aqui defino mis propios tipos de variables
 TIntArray    = array[0..15] of shortint;
 TSingleArray = array[0..15] of currency;
 
  Tusuarios = class(TObject)
   Constructor Create;
 
  private
   idU, cuentaU, subcU  :  TIntArray;
   supCder, supSder,totalU    :  TSingleArray;
   nombreU, cultivoU    :  TStrings;
   ap : shortint;  {Apuntador, lleva el numero de recibos en el cobro actual}
   
  public
 
   procedure inicializa();
   procedure add(id : Integer; cuenta :Integer; Sub : Shortint; nombre : String; supConDer : Currency ; supSinDer:Currency; cultivo:String;total : Currency) ;
  // procedure delete(id : shortint);
 
   function GetID(Indice: Shortint) :Integer;
   function GetNombre   (Indice: Shortint) :string;
   function GetSupCder (Indice : Shortint):Currency;
   function GetSupSder (Indice : Shortint) :Currency;
   function GetCultivo (Indice : Shortint) :string;
   function GetImporteU(Indice : Shortint):Currency;
   function GetImporteTotal:currency;
   function GetCuenta  (Indice :Shortint):string;
   function GetSubcuenta  (Indice :Shortint):string;
 
  end;
 
implementation
 
uses Math;
 
constructor Tusuarios.create;
begin
  
  nombreU := Tstringlist.create;
  cultivoU := Tstringlist.create;
  ap := 0;
 
 
 
 
 
end;
 
procedure Tusuarios.inicializa;
begin
  ap := 0; //inicializamos ap que es el apuntador
end;
 
procedure Tusuarios.add (id : Integer;cuenta :Integer; Sub : Shortint; nombre 
  :String;supConDer : Currency ; supSinDer:Currency; cultivo:String; total :Currency);
begin
    idU[ap] := id;
    cuentaU[ap] := cuenta;
    subcU[ap]:= Sub;
    nombreU.Add(nombre);
    supCder[ap] := supConDer;
    supSder[ap] := supSinDer;
    cultivoU.Add(cultivo);
    totalU[ap] := total;
     ap := ap+1;
end;
 
function TUsuarios.GetID(Indice: Shortint): Integer;
begin
  result := idU[Indice];
end;
 
function TUsuarios.GetNombre(Indice: Shortint): string;
begin
  result := nombreU[Indice];
end;
 
function TUsuarios.GetSupCDer(Indice: Shortint): Currency;
begin
  result := supCder[Indice];
end;
 
 function TUsuarios.GetSupSDer(Indice: Shortint): Currency;
begin
  result := supSder[Indice];
end;
 
function TUsuarios.GetCultivo(Indice: Shortint): string;
begin
  result := cultivoU[Indice];
 
end;
 
function TUsuarios.GetImporteU(Indice: shortint): Currency;
begin
  result := totalU[indice];
end;
 
function TUsuarios.GetImporteTotal: Currency;
var i : Shortint;
begin
  for i := 0 to 15 do begin
 
   Result :=totalU[i]+totalU[i];
  end;
 
end;
 
function TUsuarios.GetCuenta(Indice: Shortint): String;
begin
  result := IntToStr(cuentaU[Indice]);
end;
 
function TUsuarios.GetSubcuenta(Indice: Shortint): String;
begin
  result := IntToStr(subcU[indice]);
 
end;
 
 
 
 
end.

pero tengo otra duda,en la parte de GetImporteTotal es donde saco el importe de todos los usuarios pero siempre me saca 0 no se por que asi esta

delphi

function TUsuarios.GetImporteTotal: Currency;
var i : Shortint;
begin
  for i := 0 to 15 do begin
 
   Result :=totalU[i]+totalU[i];
  end;
 
end;

Si ves otros errores me avisas,Tambien no se como eliminar un elemento de un array espero puedas ayudarme
Bendiciones

[Delphius]

Hola edorantes,
Me parece que no estás leyendo con la debida atención mis palabras. No puedes eliminar elementos del array. Al ser estático y fijo no se puede dimensionar, por tanto siempre tendrá reservado el tamaño indicado.
La única vía para borrar o eliminar de éste es sobreescribir en la posición determinada con valores nulos o vacios. Por ejemplo: si es un integer, que sea 0 (cero), a un string con cadena vacía; etc.
En donde si puedes proceder con una liberación será en los TStrings.
Por esto te he comentado que lo más adecuado para resolver el tema es llevar un diseño basado en dos clases: una clase que administre una lista de otra. De este modo uno puede añadir, borrar, insertar, y/o modificar a su antojo sin preocuparse de estar declarando arrays de tamaños fijos.

Y aún si a esos arrays los declararas de forma dinámica:

delphi

type
  TArrayDinamico = array of Double;

Tendrás serias dificultades para llevar a cabo una eliminación debido a que deberás implementar un algoritmo de "corrimiento" y sobreescritura de una posición por la anterior/siguiente. Es decir, supongamos que inicialmente tu tienes el vector de tamaño 10:

delphi

SetLength(MiVector, 10);

Y más adelante debes eliminar el 5to elemento:
1 - 2 - 3 - 4 - x - 5 - 6 - 7 - 8 - 9 - 10

El nuevo vector deberá entonces contener el dato de los 9:
1 - 2 - 3 - 4 - 6 - 7 - 8 - 9 - 10

Esto se consigue reemplazando lo que hay en la 5ta posición por la 6ta, el de 6ta por la 7ma y así hasta llegar al final. Luego si ya es posible redimensionar:

delphi

SetLength(MiVector, 9);

Si en lugar de este diseño lo hubieras llevado a un planteo de dos clases como el que expuse basta con emplear aprovechar la clase TObjectList para armar la lista. La clase TObjectList es capaz de agregar, insertar y eliminar objetos de manera totalmente transparente y sin problemas. ¡Chau vectores!

Tu estás mezclando la "vieja escuela" con la nueva... estás mezclando estructurado con OO. De poder se puede, pero en la forma en como lo estás llevando es, con toda disculpas, caótica. Como ya he dicho: estás almacenando cada atributo en vectores/listas por separado. En su lugar aconsejo definir una propia clase que contenga a estos atributos y luego por tanto armar una lista con objetos de esta clase.

Respecto a tu duda sobre GetImporteTotal fíjate que estás sobreescribiendo el valor de result y no acumulándolo. 

Y como nota final: yo reemplazaría el shortint por integer. A menos que en verdad existiera una imperiosa necesidad de "ahorrarse" bytes yo me decantaría directamente a pasarlo a integer. En una arquitectura de 32-bits el registro de la CPU son de 32-bits por lo que de todas formas el compilador va tener que enmascarar al tipo en un registro de 32-bits.
De hecho, en el ciclo el compilador va a utilizar el registro contador y este ya es de 32. El forzarlo a que sea de shortint simplemente no ahorra nada, solo genera indirección y se malgasta ciclos de procesamiento.

Saludos,

[edorantes]

Gracias Delphius por tus consejos, esta todo resuelto para poner vaciar el arreglo solo bastaba con poner el apuntador en ceros
muchas gracias