Newsgroup: it.comp.lang.delphi
Titolo: specificare valori costanti di un'array di una classe.

Ringrazio in anticipo chiunque vorrà aiutarmi.
ho una lacuna riguardante la dichiarazione dei valori di una costante.
Mi spiego con un caso pratico che sia la cosa più semplice:
-Mettiamo che io faccia la seguente dichiarazione:
type 
	Tpersona = class
		nome = string;
		cognome = string;
	end;
-Ora intendo dichiarare un'array di tipo Tpersona, però deve essere
costante, ma non conosco la sintassi per specificare i vari valori.
cost 
	ArrayDiPersone: array [0..5] of TPersona = ...[cosa?]
-Il risultato dovrebbe essere lo stesso di dichiarare ArrayDiPersone
come variabile e poi inserire i dati successivamente
ArrayDiPersone[0].nome = 'nome0';
ArrayDiPersone[0].cognome = 'cognome0';
...
...
Però mi interesserebbe sapere come si fa con la dichiarazione della
costante.
Spero di essermi espresso chiaramente.
Grazie.

 come variabile e poi inserire i dati successivamente
a naso direi che non lo fai proprio.
Come conti di istanziare le classi TPersona?
Ciao

 costante.
Purtroppo hai chiesto diverse cose che sono incongruenti tra loro. :-D
Innanzitutto, non è possibile utilizzare una classe nelle costanti 
poichè manca completamente la trattazione della creazione delle singole 
istanze, come qualcun altro ti ha già suggerito.
In secondo luogo, nell'esempio di codice che hai fornito tenti di 
modificare i campi della tua classe...pertanto, che razza di costante 
sarebbe? :-P
Forse non hai espresso al meglio il tuo scopo, piuttosto che il modo con 
cui desideri ottenerlo... ;-)
Comunque, potresti tramutare la tua classe in un *record* e creare un 
vettore "costante" che contenga un determinato numero di tali record, 
già inizializzato.
Ti riporto un esempio che ho fatto al volo per spiegarti ciò che intendo.
type
   TFriend = record
     Name: String;
     Surname: String;
   end;
const
   Friends: array [0..5] of TFriend = (
     (Name: 'Chandler'; Surname: 'Bing'),
     (Name: 'Ross'; Surname: 'Geller'),
     (Name: 'Phoebe'; Surname: 'Buffay'),
     (Name: 'Rachel'; Surname: 'Greene'),
     (Name: 'Joey'; Surname: 'Tribbiani'),
     (Name: 'Monica'; Surname: 'Geller')
    );
Tralasciando la fonte alla quale mi sono ispirato per i tipi e i dati di 
esempio, questo codice definisce un record e crea un vettore contenente 
un numero prefissato di tali record debitamente inizializzati campo per 
campo, e ovviamente non modificabili.
Se hai la necessità di inizializzare tali campi, credo che l'unica 
soluzione in tuo possesso sia quella di usare una sola costante con il 
numero di oggetti da creare e una variabile vettore avente tale numero 
come dimensione; a runtime, una routine apposita crea le istanze e ne 
memorizza i riferimenti all'interno del vettore.
Potresti usare l'esempio del record riportato sopra per mantenere, ad 
esempio, i dati predefiniti con cui inizializzare le istanze della tua 
classe sottoforma di comoda costante, facilmente individuabile e 
modificabile in un secondo momento. Che te ne pare?
Ciao! :-)
-- 
Marco «Alka» Breveglieri
  ABLS Team S.n.c. - Software & Web
  Via De Gasperi, 14
  42019 Scandiano (Reggio Emilia)
 
http://www.abls.it

 	end;
io la riscriverei:
TPersona = class
public
   constructor Create(const ANome, ACognome: string);
published
   property nome: string read FNome;
   property cognome: string read FCocgnome;
end;
Poi, premi ctrl+shift+c
Infine, nel costruttore:
inherited Create;
FCognome := ACognome;
Nome := ANome;
Infine:
procedure qualcosa;
var
   mialista: TList;
begin
   mialist := TList.Create;
   mialista.Add(TPersona.Create('Donald', 'Duck'));
   mialista.Add(TPersona.Create('Cindy', 'Crawford');
end;
AS

...

Grazie mille, l'esempio che hai riportato rispecchia esattamente ciò
che volevo fare.
La discussione della valorizzazione runtime e cose più complesse sono
frutto di una mia errata spiegazione di ciò che volessi sapere.
Putroppo avevo idee un pò confuse sugli strumenti da usare e sul come
ecc... ma il tuo esempio mi ha illuminato perchè non so come sei
riuscito in qualche modo a decifrare ciò che mi interessava sapere :)
Grazie anche agli altri che mi hanno voluto dare una mano :)

 riuscito in qualche modo a decifrare ciò che mi interessava sapere :)
Tutto ciò ha un nome: cu...ehm...fortuna. :-)


 AS
Gabriele

Gabriele
	Ciao
	MassimoB
 
---------------------------
http://www.massimobeschi.it/

 gestione della memoria dei suoi items ... vedi doc
La ObjectList la utilizzo solo quando ho Item formati da classi diverse (un
pò come fanno i TFields)
ma se gli Item sono dello tipo della classe conviene (secondo me) utilizzare
le TCollection
che sono di gran lunga più incapsulate come classi.
Con le ObjectList comunque per utilizzare poi devi fare dei Cast sugli Item
qualcosa del tipo:
(MiaLista.Item[0] as TMiaClasse).FAiQualcosa
che utilizzata dall'esterno non è molto incapsulato come comportamento e
quindi per fare una cosa
fatta bene dovresti farti comunque una classse che utilizza una ObjectList.
A questo punto utlizzo una collection in modo che gli item sono già del tipo
che mi serve.
Ora non ricordo bene ma nello sviluppo di un componente se utilizzi
le collection già hai il PropertyEditr pronto per aggiungere eliminare
Item... nel caso di una Objectlist questa cosa non
ce l'hai dovresti farti un propertyeditor per l'utilizzo.
Ciao
Gabriele


 ce l'hai dovresti farti un propertyeditor per l'utilizzo.
La soluzione che adotterei io è un'altra: utilizzerei un'ObjectList 
magari incapsulandola all'interno di una classe preposta alla gestione 
degli oggetti appartenenti al mio tipo specifico di classe, dotata di 
proprietà array in grado di restituire i riferimenti agli oggetti già 
"castati" al tipo corretto.
Una domanda: proprio per il fatto che le Collection hanno il supporto 
alla persistenza, non sono da considerare più pesanti rispetto alla 
ObjectList?
Ciao!


 Ciao!
Ciao
gabriele

 carimento o cosa?
Scusa, sono stato impreciso. Per "pesanti" indicavo il fatto che 
occupano un quantitativo maggiore di memoria, vengono generate 
informazioni aggiuntive nella RTTI... in definitiva, a meno di non 
utilizzarle a designtime (per cui divengono indispensabili per via delle 
funzionalità di editing dall'Object Inspector), non trovo in esse né più 
né meno funzionalità rispetto ad una normale ObjectList (o ad una 
TList). Magari ricordo male io...
Ciao! :-)
