¿Como recorrer un conjunto?

[[Delphius]]

Buenas foristas...

Esta pregunta es, segurísimo, una tontera (y me siento como un tarado con sólo preguntarla) pero no le encuentro vuelta.

La situación es esta: manejos de conjuntos y tipos enumerados.
Bueno, tengo un tipo enumerado:

// Si bien los nombres no son esos... el ejemplo es válido
TEnum = (eUno = 1, eDos = 2, eTres = 3, eCuatro = 4,... eOcho = 8);

TSetEnum = set of TEnum.

Hasta alli se entiende.

Tengo un procedimiento que debe recibir como parámetro un TSetEnum, y por cada elemento del conjunto debo realizar operaciones, que si bien son similares... debo ir manteniendo dicha sumatoria. Es decir, sumar todos los resultados.

La pregunta es: ¿Cómo puedo recorrer el conjunto y dependiendo del valor que vaya leyendo hacer la operatoria indicada?Es decir lo que quiero conseguir es:

Código Delphi [-]
sum := 0;
for {cada elemento del conjunto} do
  begin
    case {elemento del conjunto} of
      eUno: begin
              {operatoria...}
              inc(sum,resultado);
            end;
      ...
      eOcho: begin
             end;
    end; //case
  end;

Lo que se pretende conseguir es que el usuario ingrese una cantidad arbitraria de operaciones (es por eso el TSetEnum). Y que se regrese el resultado.
Ha decir verdad... ha pesar de haber trabajado con conjuntos (no mucho... pero algo), nunca tuve que recorrerlo... Estaba pensando en la posibilidad de usar un array dinámico, pero no le veo sentido usar un array (crearlo, liberarlo, darle tamaño)... si a lo mejor se puede hacer con un simple conjunto. Claro está... que si el conjunto se ingresa vacio no se hace nada. Me puse a ver la ayuda (y vaya que es escasa) y no encontré algo que me diga como se podría recorrer un conjunto.

Me he enterado por gente de Sam Sistemas (representantes de Borland en Argentina) que me comentaban que en la versión 2006 se puede hacer un:

Código Delphi [-]
for in Conjunto do

Pero... ¡porqué no lo pusieron antes!

Espero no haber dicho algo tonto...
Saludos,

[[seoane]]

Estoy confundido. En un conjunto no puede haber un elemento repetido, es decir:

Código Delphi [-]
var
  SetEnum: TSetEnum;
begin
  SetEnum:= [eUno,eDos];
  SetEnum:= SetEnum + [eUno]; 
  // El valor de SetEnum sigue siendo [eUno,eDos] la ultima operacion no sirvio para nada
end;

Así que no entiendo para que necesitas un bucle, algo así serviría:

Código Delphi [-]
if eUno in Conjunto then
begin

end;
if eDos in Conjunto then
begin

end;

....

if eOcho in Conjunto then
begin

end;

Puede que tu estés confundiendo un conjunto con un array o una lista.

[roman]

Código Delphi [-]
var
  e: TEnum;
  c: TSetEnum;

begin
  for e := Low(TEnum) to High(TEnum) do
    if e in c then
      { haz algo con e }
end;

// Saludos

[[Lepe]]

Lo que has dicho no es ninguna tontería, de hecho no tiene solución inmediata.

Para poder usar esto, no puede haber saltos en el tipo Enum, es decir:

Código Delphi [-]
TEnum = (eUno = 1, eDos = 2, eTres = 8, eCuatro = 9);

no puedes dar valores no consecutivos a los índices, normalmente se hace así:

Código Delphi [-]
TEnum = (eUno = 1, eDos , eTres , eCuatro);

así el compilador le dará valores correlativos sin saltos. Después puedes usar algo así:

Código Delphi [-]
var I:TEnum;
    conjunto : TSetEnum;
begin
conjunto  := [eUno, eDos]
sum := 0;
for i:= Low(TEnum) to High(TEnum) do
  if i in conjunto then

El conjunto no puedes recorrerlo, como mucho, puedes recorrer el tipo enumerado.

EDITO:
román, ¿no deberías estar ya en la cama?


Saludos

[roman]

Empezado por Lepe

Para poder usar esto, no puede haber saltos en el tipo Enum

¿Por qué no? El ciclo que puse puedo recorrerlo aún con saltos en la secuencia.

// Saludos

[[Delphius]]

Gracias seoane, roman y Lepe por responder.

Conque el culpable era Low() yHigh().... ¡ya se las veran conmigo esos dos!

¡No sabía que pdían usarse para los tipos enumerados! Me he cansado de emplearlos en arrays dinámicos y ni se me ocurrió intentarlo ahora....

Veré que tal me sale ahora.

Empezado por seoane

En un conjunto no puede haber un elemento repetido

Asi es. En un conjunto no se admiten repetidos.
seoane, el código que me envias es precisamente lo que me quería evitar... imaginate un conjunto con 10, 20, 100 elementos... Y sabiendo que las operaciones son similares, con más razón.

gracias a todos por brindar su ayuda.
Saludos,

[[Lepe]]

Empezado por roman

¿Por qué no? El ciclo que puse puedo recorrerlo aún con saltos en la secuencia.

// Saludos

¿Donde he leido yo que era una incomodidad ese salto en los tipos enum...? No sé, lo he estado buscando pero no lo encuentro.

Creo recordar que al incluir un salto, después no permitía hacer algo en especial, jo.... esto no es serio

Está claro que si incluimos un salto, después no podemos hacer cosas de este estilo:

Código Delphi [-]
type a = array [TEnum] of String;

...pero no iba por ahí la cosa, había algo más... creo recordar se trataba de esto:

Código Delphi [-]
for i:= integer(eUno) to integer(eOcho) do

... no sé, de hecho tomé la decisión hace tiempo de no incluir saltos en los tipos Enum, pero no recuerdo el por qué

Saludos

[[basti]]

Creo que a partir de delphi 2005 se puede usar la clausula 'in' dentro del for, que resulta más cómoda. Yo uso delphi 7, así que mejor que alguien te confirme esto.

Código Delphi [-]
var
  i: TEnum;
  c: TSetEnum;

begin
  for i in c do
  begin
     // i sólo tendrá los valores del conjunto
  end;
end;

[roman]

Empezado por Lepe

Está claro que si incluimos un salto, después no podemos hacer cosas de este estilo:

Código Delphi [-]
type a = array [TEnum] of String;

Poder, podemos, al menos el compilador no protesta. Lo que pasa es que no es lo que posiblemente creamos que sea. Es decir, cuando declaramos un tipo enumerado con saltos

Código Delphi [-]
TEnum = (eUno = 1, eDos = 2, eTres = 3, eCuatro = 4, eOcho = 8);

estamos declarando más de lo que se ve, como puede observarse si hacemos:

Código Delphi [-]
var
  e: TEnum;

begin
  for e := Low(TEnum) to High(TEnum) do
    ShowMessage(IntToStr(Ord(e)));
end;

En otras palabras, TEnum no es más que el intervalo

Código Delphi [-]
type
  TIntervalo = 1..8;

con nombres especiales para el 1, 2, 3, 4 y 8 pero no para el 5, 6 y 7.

Y claro que en un arreglo como el que pones, esto sería particularmente raro porque se trata de un arreglo con más elementos de los que aparentemente tendría.

// Saludos