Newsgroup: it.comp.lang.delphi
Titolo: Array di TEdit

Salve! vorrei sapere se è possibile creare un array di TEdit in modo da
poter eseguire la somma dei numeri contenuti in questi con un semplice ciclo
del tipo
For I:=1 to N do
    somma:=somma+StrToInt(Edit[I]);
Ho provato a dichiarare, nella parte dell var,
risultati: array [1..8] of TEdit
e non mi da errore, ma non posso fare in modo che un TEdit abbia come nome
risultati[1]. Come posso fare? Crearmi da solo un nuovo componente?

 Salve! vorrei sapere se č possibile creare un array di TEdit in modo da


     somma:=somma+StrToInt(Edit[I]);
Se per "...il contenuto..." intendi ciò che contenuto dalla proprietà Text
del TEdit, puoi agire in questo modo:
Var Somma, i : Integer;
Begin
    Somma := 0;
    For i := 1 to N do
        with TEdit(FindComponent('Edit' + IntToStr(N))) do
          If Text <> '' then Somma := Somma + StrToInt(Text);
End;
Ciao
Francesco.

         with TEdit(FindComponent('Edit' + IntToStr(N))) do
Ma
with TEdit(FindComponent('Edit' + IntToStr(i))) do
Ciao
Francesco.

 ha scritto nel messaggio
news:nrf29.27508$lu5.7...@twister1.libero.it...

form con tre componenti :button1,edit1,edit2
edit1.text:='1';
edit2.text:='2';
procedure TForm1.Button1Click(Sender: TObject);
var
i:integer;
n:integer;
begin
n:=0;
for i:=0 to ComponentCount-1 do
   if Components[i] is TEdit then
   n:=n+StrToInt((Components[i] as TEdit).Text );
Button1.Caption:=IntToStr(n)
end;
end.
eseguendo la caption di button1 diventa '3'
spero di esserti stato d'aiuto
p.s. è chiaro che sulla form potresti avere uno o più TEdit che non
c'entrano con quello che vuoi fare, allora potresti filtrarli con la
proprietà tag (ti servono 10 TEdit? numeri le rispettive tag da 0 a 9 e
cambi l'espressione
 if Components[i] is TEdit then   in
( if Components[i] is TEdit) and ( Components[i].tag ) in [0..9] then

El Dono wrote:

Puoi dichiari una array di componenti ma li devi poi creare a run time.
Ti riporto un po' del codice di una dll che ho scritto:
type
  {questo record contiene la riga di componenti che devono comparire nel
   pannello Punti}
  PRiga = record
    Lbl: TLabel;
    Edt: TEdit;
    CBTag, CBTrat: TCheckBox;
  end;
  {questo record contiene la riga di componenti che devono comparire nel
   pannello Moltiplica}
  MRiga = record
    Lbl: TLabel;
    Edt: TEdit;
  end;
var
  VetP: array of PRiga;
  VetM: array of MRiga;
implementation
{questa procedura viene chiamata quando viene creata la form che contiene
i pannelli Punti e Moltiplica}
procedure TEditagrafico.CreaRiga(j, i: Integer);
begin
  with VetP[j] do
  begin
    Lbl:=TLabel.Create(SBP); //SBP DEVE essere poi specificato come Parent
    with Lbl do
    begin
      Parent:=SBP; //devi indicare questa proprieta' o ti da errore
      Left:=10; //devi indicare la posizione dell'oggetto
      Top:=30*j+15; //devi indicare la posizione dell'oggetto
      Caption:=nomidati[i+1];  //non indispensabile
      Color:=clBlack;  //non indispensabile
      OnClick:=VetPLblClick; //cosi' assegni gli eventi
    end;
    Edt:=TEdit.Create(SBP);
    with Edt do
    begin
      Parent:=SBP;
      Left:=105;
      Top:=30*j+12;
      Width:=120;
    end;
    CBTag:=TCheckBox.Create(SBP);
    with CBTag do
    begin
      Parent:=SBP;
      Left:=240;
      Top:=30*j+14;
      Width:=20;
    end;
    CBTrat:=TCheckBox.Create(SBP);
    with CBTrat do
    begin
      Parent:=SBP;
      Left:=285;
      Top:=30*j+14;
      Width:=20;
    end;
  end;
  with VetM[j] do
  begin
    Lbl:=TLabel.Create(SBM);
    with Lbl do
    begin
      Parent:=SBM;
      Left:=10;
      Top:=30*(j-1)+15;
      Caption:=nomidati[i+1];
    end;
    Edt:=TEdit.Create(SBM);
    with Edt do
    begin
      Parent:=SBM;
      Left:=100;
      Top:=30*(j-1)+12;
      Width:=100;
    end;
  end;
  XMV[j]:=1;
end;
-- 
Ciao,
   Stefano

Ovviamente da qualche parte devi fare il SetLength dei vettori VetP e VetM 
visto che non ho detto quanto sono lunghi nella dichiarazione.


 with TEdit(FindComponent('Edit' + IntToStr(i))) do
Sarebbe MOLTO meglio scrivere:
var
  C: TComponent;
...
  C := FindComponent('Edit' + IntToStr(i));
  if C <> nil then
    with TEdit(C) do
    ...

     with TEdit(C) do
Mha. La sostanza non cambia, in più hai dichiarato una var e non è stata
ottimizzata in alcun modo l'esecuzione, anzi...
Se al contrario intendi parlare di "leggibilità", il discorso cambia.
;-)
Francesco.

 ottimizzata in alcun modo l'esecuzione, anzi...
Tutt'altro.  La sostanza cambia eccome.
Nel tuo codice, tu casti un valore che puo' anche essere Nil (perche'
risultato di una FindComponent) e questo e' un gravissimo errore,
perche' a run-time puo' succedere di tutto, visto che cerchi di
impostare proprieta' di un oggetto non inizializzato.  La cosa
peggiore e' che il sistema potrebbe non sollevarti alcuna eccezione. 
Quando un'operazione puo' andare a buono o cattivo fine, bisogna
sempre imporre gli opportuni controlli.

 risultato di una FindComponent) e questo e' un gravissimo errore,
Trattandosi di un array ben definito a design time e di cui si conosce
"vita, morte e miracoli", direi che il problema non si pone, quindi
preferisco ottimizzare al massimo, pianificando bene il tutto.
Giusto quel che dici ed ancor di più se si dovesse andare ad operare in una
folla di objects non ben definibili a monte. (non mi sembra il caso della
richiesta di El Dono).
Francesco. :-)

 preferisco ottimizzare al massimo, pianificando bene il tutto.
Io parlo di una regola generale, non del caso specifico, ma anche nel caso
specifico ci sarebbero da fare delle obiezioni. Il problema e' proprio in
quella "vita morte e miracoli".
L'array e' ben definito, ma non e' detto che sia ben definito il modo in cui
accedi ad esso.
Se, per errore, dimentichi di scrivere N, ma scrivi N-1 o, ancor peggio, se
quel N varia a codice e il codice si dimentica di aggiornarlo (per un bug
latente), allora e' molto probabile che, dal tuo cliente, venga fuori una
mascherina di Access Violation. O, ancora peggio, non venga fuori un bel
niente, ma i calcoli, su qualche maschera, siano errati (in questo caso,
voglio sperare che tu non scriva software che componga le dosi di anestetico
per le operazioni chirurgiche ;).
Quello che puo' succedere se la memoria viene "sporcata" con l'utilizzo di
un puntatore non inizializzato e' assolutamente indefinito e indefinibile.
In generale e' sempre bene programmare in modo difensivo. Affidarsi alle
regole "implicite" (del tipo: so quel che faccio) e lasciare il codice in
bilico su un equilibrio perfetto e' quasi sempre un errore. Pensare di
ottimizzare al massimo in modo preventivo e', invece, *sempre* un errore
(vedi gli insegnamenti di D. Knuth). Pianificare bene tutto dall'inizio
significa fare in modo che se anche vi fosse un errore nel codice, per cui
si arriva laddove non si dovrebbe arrivare, la situazione venga gestita
comunque.
E il motivo per cui e' preferibile scrivere:
function MyDiv(A, B: Double): Double;
begin
  if B = 0.0 then
    raise Exception.Create('errore di divisione per zero!');
  Result := A/B;
end;
Anziche' :
function MyDiv(A, B: Double): Double;
begin
  Result := A/B;
end;
Anche se sono sicuro che in tutto il mio codice io passero' sempre un
divisore non nullo.
E' il motivo per cui e' meglio scrivere:
function Trasforma(N: Integer): Integer;
begin
  case N of
    4: Result := -2;
    2: Result := -3;
    1: Result := -4
  else
    raise Exception.Create('Valore errato !');
  end;
end;
anziche':
function Trasforma(N: Integer): Integer;
begin
  case N of
    4: Result := -2;
    2: Result := -3;
    1: Result := -4
  end;
end;
Anche se sono sicuro che in tutto il codice io passero' alla funzione sempre
e solo 1, 2, 4.
--------------------------------
Inviato via 
http://usenet.libero.it

 per le operazioni chirurgiche ;).
Buona domenica.
Francesco.
P.S.
Spero non risponda oggi, significherebbe che le tue ferie sarebbero
cominciate con un fantastico soggiorno a... 'Akkà stò'. Io sono stato
fermato dagli impegni della mia metà e come vedi sono quì. :-(

 giungendo quindi allo stesso «risultato». 
No.
Quando scrivo il codice, cerco di farlo in modo che non vi siano le
condizioni per eventuali errori nascosti.  In un codice come il tuo, c'e'
la condizione perche' vi siano errori latenti.  
E' visibile e gestibile da subito.  
Ricordati:
"We should forget about small efficiencies, say about 97% of the time:
premature optimization is the root of all evil." -- Donald Knuth 
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 ha scritto nel messaggio
news:nrf29.27508$lu5.7...@twister1.libero.it...
