Saber el Style de una fuente

[jachguate]

Solo quiero acotar que no me parece que un set se guarde en un solo byte.

Esto limitaria el conjunto a solo ocho posibles elementos... y hay conjuntos con mas.

No puedo buscar ahora, pero estoy seguro que Delphi ajustará el tamaño de la variable a la cantidad de elementos del conjunto, por lo que en ocasiones se tratará de un tipo de 16 bits de longitud (como un Word), pero también puede ser de 32... un Longint o LongWord por ejemplo, o mas... con lo que ya quedaría bueno representarlo como un conjunto o como un Int64, etc.

Delphi, cuando almacena un conjunto, simplemente tiene una lista ordenada de todos los posibles valores que pueden pertenecer a este, y el conjunto no es mas que un BitMap que indica los valores presentes en el conjunto con 1 y los no presentes con 0.

Si los posibles valores son del tipo TFontStyle, que está definido por la siguiente enumeración (en ese orden):

fsBold, fsItalic, fsUnderline, fsStrikeOut

Se necesitarán solamente cuatro bits para representar un Set of TFontStyle, y un conjunto con los valores [fsBold, fsUnderline] será dado por el bitmap

1010

y un conjunto vacio, por el bitmap

0000

En fin... quizas sea buena idea hacer un SizeOf antes de decidir el tipo de datos a usar para almacenar el conjunto como un entero (o cualquier otro tipo escalar).

Hasta luego.

[delphi.com.ar]

Empezado por jachguate

Solo quiero acotar que no me parece que un set se guarde en un solo byte.

Esto limitaria el conjunto a solo ocho posibles elementos... y hay conjuntos con mas.

Puedes hacer una prueba mas que sencilla:

Código Delphi [-]
Format('FontStyle: %d ComponentState: %d', [SizeOf(TFontStyles), SizeOf(TComponentState)]);

Un comentario, yo he probado eso para poder sugerir un cast, pero no se poqué falló, me dio un error como que no era posible este tipo de cast, voy a morir con la duda de que había echo

Saludos!

[roman]

Empezado por jachguate

No puedo buscar ahora, pero estoy seguro que Delphi ajustará el tamaño de la variable a la cantidad de elementos del conjunto, por lo que en ocasiones se tratará de un tipo de 16 bits de longitud (como un Word), pero también puede ser de 32... un Longint o LongWord por ejemplo, o mas... con lo que ya quedaría bueno representarlo como un conjunto o como un Int64, etc.

Hasta donde he visto es cierto lo que dices. El tamaño depende de el rango máximo de valores. En este caso es un byte pero en otros habrá que hacer el moldeo a otro tipo de entero.

// Saludos

[delphi.com.ar]

Eso lo aseguro, que el compilador lo reduce a la mínima expresión, tenía la idea de que había una directiva al compilador para modificar esto, pero no la encotré.

Por otro lado, aquí tienen un ejemplo como otros conjuntro extaños siguen ocupando lo mínimo indispensable:

Código Delphi [-]
type
  TMiTipo1 = (msValorA1, msValorA2, msValorA3);
  TMiSet1  = set of TMiTipo1;

  TMiTipo2 = (msValorB1 = 253, msValorB2, msValorB3);
  TMiSet2  = set of TMiTipo2;

  {$MINENUMSIZE 4}
  TMiTipo3 = (msValorC1, msValorC2, msValorC3);
  TMiSet3  = set of TMiTipo3;
  {$MINENUMSIZE 1}

  TMiTipo4 = 0..31;
  TMiSet4  = set of TMiTipo4;

  TMiTipo5 = 1..32;
  TMiSet5  = set of TMiTipo5;

  TMiTipo6 = 'a'..'z';
  TMiSet6  = set of TMiTipo6;
....

procedure TForm1.FormCreate(Sender: TObject);
begin
  Memo1.Lines.Add(Format('1> Tamaño: %d Tipo: %d Valor del Primer Item:%d', [SizeOf(TMiSet1), SizeOf(TMiTipo1), Integer(msValorA1)]));
  Memo1.Lines.Add(Format('2> Tamaño: %d Tipo: %d Valor del Primer Item:%d', [SizeOf(TMiSet2), SizeOf(TMiTipo2), Integer(msValorB1)]));
  Memo1.Lines.Add(Format('3> Tamaño: %d Tipo: %d Valor del Primer Item:%d', [SizeOf(TMiSet3), SizeOf(TMiTipo3), Integer(msValorC1)]));
  Memo1.Lines.Add(Format('4> Tamaño: %d Tipo: %d', [SizeOf(TMiSet4), SizeOf(TMiTipo4)]));
  Memo1.Lines.Add(Format('5> Tamaño: %d Tipo: %d', [SizeOf(TMiSet5), SizeOf(TMiTipo5)]));
  Memo1.Lines.Add(Format('6> Tamaño: %d Tipo: %d', [SizeOf(TMiSet6), SizeOf(TMiTipo6)]));
end;

Saludos!

[jachguate]

jejeje... me has hecho cargar delphi para probar, y de paso refrescar un poco la memoria con los conjuntos.

El compilador reduce el tamaño del conjunto a su minima expresión. Al contrario tuyo, yo no recuerdo ninguna directiva para cambiar este comportamiento...

Un conjunto no puede tener mas de 256 posibles elementos... con lo que el tamaño máximo de este tipo de dato en memoria será de 32 bytes (256 bits).

Me he atrevido a agregar un par de tipos mas a tu código, siendo estos:

Código Delphi [-]
  TMiTipo7 = 0..255;
  TMiSet7  = set of TMiTipo7;

  TMiTipo8 = 1..256;
  TMiSet8  = set of TMiTipo7;

...
// y por supuesto, 
  Memo1.Lines.Add(Format('7> Tamaño: %d Tipo: %d', [SizeOf(TMiSet7), SizeOf(TMiTipo7)]));
  Memo1.Lines.Add(Format('8> Tamaño: %d Tipo: %d', [SizeOf(TMiSet8), SizeOf(TMiTipo8)]));

Los resultados obtenidos son:

Empezado por ejemplo.exe

1> Tamaño: 1 Tipo: 1 Valor del Primer Item:0
2> Tamaño: 1 Tipo: 1 Valor del Primer Item:253
3> Tamaño: 1 Tipo: 4 Valor del Primer Item:0
4> Tamaño: 4 Tipo: 1
5> Tamaño: 5 Tipo: 1
6> Tamaño: 4 Tipo: 1
7> Tamaño: 32 Tipo: 1
8> Tamaño: 32 Tipo: 2

Me llama poderosamente la atención el caso 5>, en que el compilador ha usado 5 bytes para almacenar el conjunto, cuando en realidad es posible hacerlo solamente en 4. Precisamente por ello he incluido los dos últimos tipos... para ver si se animaba a usar mas de 32 bytes...

Hasta luego.