Ciclo attraverso enumerazione irregolare in Delphi

Question

1) Qualcuno sa se è possibile eseguire il ciclo di un'enumerazione irregolare in Delphi (XE)?

Il ciclo su una normale numerazione è ok. Da Delphi Basics:

var 
    suit : (Hearts, Clubs, Diamonds, Spades); 
begin 
// Loop 3 times 
For suit := Hearts to Diamonds do 
    ShowMessage('Suit = '+IntToStr(Ord(suit))); 
end; 

Ma, se 'vestito' invece è dichiarata come

var 
    suit : (Hearts=1, Clubs, Diamonds=10, Spades); 

esso loop 10 volte. Non sorprendente, ma mi piacerebbe loop 3. L'unica soluzione che ho trovato finora è la conversione di un'enumerazione in un set e utilizzare il 'for ... in'-loop come su delphi.about.com.

Quindi, se la risposta alla domanda 1) è no, quindi:
2) Come convertire dall'enumerazione per impostare in Delphi?

Il contesto in cui lo sto utilizzando è un array di componenti di edit-box (TEdit) che ha una numerazione irregolare (edit1, edit5, edit7, edit3, ...). Mentre è possibile riordinare tutte le caselle di modifica, rimuove il motivo dell'utilizzo dell'enumerazione come modo flessibile per consentire l'aggiunta di una casella di modifica nel mezzo dell'enumerazione.

Answer 1

Non ho un compilatore Delphi a portata di mano in questo momento, ma ho tink che l'approccio di Gabr può essere piuttosto significativamente migliorata facendo

type 
    TSuit = (Hearts = 1, Clubs, Diamonds = 10, Spades); 

const 
    Suits: array[0..3] of TSuit = (Hearts, Clubs, Diamonds, Spades); 

Chissà, forse non anche compilare.

Answer 2

Ciclo con Ord (Cuori) a Ord (Picche)?

Answer 3

type 
    TSuit = (Hearts=1, Clubs, Diamonds=10, Spades); 

var 
    suit: TSuit; 
    suitEnum: array [1..4] of TSuit; 

//initialization 
suitEnum[1] := Hearts; 
suitEnum[2] := Clubs; 
suitEnum[3] := Diamonds; 
suitEnum[4] := Spades; 

for suit in suitEnum do 
    DoSomething(suit); 

Answer 4

Un'opzione sporco, utile per i piccoli enumerazioni:

type 
    TSuit = (Hearts = 1, Clubs, Diamonds = 10, Spades); 
var 
    Suit: TSuit; 
begin 
    for Suit in [Hearts, Clubs, Diamonds] do 
    WriteLn(Ord(Suit)); 

Funziona bello in Delphi 2007. Non so su versioni precedenti. Essere consapevoli, utilizzando for Suit in [Hearts..Diamonds] do ha lo stesso problema del ciclo.
Btw, io uso WriteLn() perché l'ho provato in un'applicazione console. :-)

Answer 5

Io uso sempre

var 
    s: TSuit; 
begin 
    for s := Low(TSuit) to High(TSuit) do 
    {something}; 
end; 

Answer 6

Si dovrebbe comprendere (e spesso non lo è) che il momento in cui mettere le assegnazioni ordinali rigidi in un'enumerazione, cessa a tutti gli di essere un pascaliana enumerato tipo - diventa semplicemente un "sacco di costanti", che non è la stessa cosa. Questo è ciò che i programmatori C chiamano enumerazioni. Tuttavia, un tipo enumerato Pascalian è ORDINALE in tutti i criteri: ha valori consecutivi discreti che rispondono in modo significativo alle operazioni di base ORD, PRED, SUCC. Le enumerazioni in Do non lo fanno, e nemmeno enumano in Pascal una volta forzati gli ordinali.

QUESTO è il motivo per cui RTTI di Delphi si rifiuta fondamentalmente di restituire le informazioni sul tipo una volta che è stato fatto. A tutti gli effetti il ​​tipo è essenzialmente un tkUnknown e deve essere trattato come un "sacchetto" di costanti in fase di compilazione. È solo perché gioca ancora a parole per essere un ordinale e ha un supporto (a volte tremolante) per l'uso in insiemi che le persone sono indotte a credere che dovrebbe comportarsi ancora come un tipo enumerato appropriato. È meglio capirlo per quello che è veramente: un cenno ai valori enumerati in C. Evita di mescolare la metafora del codice!

Se si esegue questa operazione, la soluzione diventa ovvia: si utilizza un tipo enumerato (corretto) per indicizzare una matrice corrispondente di COSTANTI. Quindi puoi rendere gli ordinali come vuoi e le enumerazioni mantengono le loro complete definizioni RTTI come una corretta enumerazione. Quindi: il tuo TIPO ENUMERATO contiene valori ordinali invariati. Ottenete i vostri numeri divertenti indicizzando l'array di costanti usando l'enumerazione -ergo array [MyEnums] di byte = (1,3,8,22,99, qualunque)