Discussion :

[der§en]

Voila, un record, qui normalement ne devrait faire que 16 bits soit un Word, et donc un sizeof = 2.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
type
  TLocalisation = packed record
    Altitude: 0..4095;
    Biome:    0..15;
  end;

Sauf que lors du contrôle de l'espace occupé, j'ai ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
var
  taille: word;
begin
  taille := Sizeof(TLocalisation);
 
  ShowMessage('Taille = ' + taille.ToString);

Une idée de mon erreur (bien qu'il me semble que cela donnais bien 2 dans mon ancien Delphi 10.2) ?

[ShaiLeTroll]

Delphi ne gère pas de champ de moins d'un byte

4095 c'est 12 bit aligné sur 16 bit
15 c'est 4 bit aligné sur 8 bit;

la packed lui évite un alignement sur 4 voire 8 octet, par exemple un champ 16 bit en plus après Biome, packed, il suit directement, en normal, il aurait été aligné à 4 et tu aurais un petit trou d'un octet.

Donc 24 bits confirmé

ce n'est pas comme en C ou tu peux écrire

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
struct  TLocalisation {
    unsigned short Altitude: 12;
    unsigned short Biome: 4
}

Et encore, il aligne aussi le bit field, la ça tombe pile dans la taille d'un short

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
struct  TLocalisation {
    unsigned short Altitude: 12;
    unsigned char Biome: 4
}

Dans ce cas, est-ce qu'il cumule short 12 + char 4, où comme le type est différent, il ajoute un trou de 4 bit, donc aligné aussi sur 16 pour Altitude

Qui provoque des instructions complexes pour la manipulation, en dehors d'un header de fichier ou de flux, mieux vaut éviter de nos jours, on a assez de RAM pour supporter un peu d'alignement et éviter du OR, AND, SHR, on sacrifie un peu de mémoire au profit du CPU

[der§en]

Je vais refaire le même test sur une ancienne version !

A suivre....

[ShaiLeTroll]

Je vais refaire le même test sur une ancienne version !

A suivre....

Tu peux, j'en suis certains puisque l'API Windows en contient

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
typedef struct _LDT_ENTRY {
  WORD  LimitLow;
  WORD  BaseLow;
  union {
    struct {
      BYTE BaseMid;
      BYTE Flags1;
      BYTE Flags2;
      BYTE BaseHi;
    } Bytes;
    struct {
      DWORD BaseMid : 8;
      DWORD Type : 5;
      DWORD Dpl : 2;
      DWORD Pres : 1;
      DWORD LimitHi : 4;
      DWORD Sys : 1;
      DWORD Reserved_0 : 1;
      DWORD Default_Big : 1;
      DWORD Granularity : 1;
      DWORD BaseHi : 8;
    } Bits;
  } HighWord;
} LDT_ENTRY, *PLDT_ENTRY;

en delphi, tu dois utiliser des mask et SHR/AND ou SHL/OR

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
const
  { bitfield constants for Flags field of TLDTEntry }
 
  LDTF_BASEMID      = DWORD($FF000000);  {8}
  LDTF_TYPE_8       = $00F80000;  {5}
  LDTF_DPL          = $00060000;  {2}
  LDTF_PRES         = $00010000;  {1}
  LDTF_LIMITHI      = $0000F000;  {4}
  LDTF_SYS          = $00000800;  {1}
  LDTF_RESERVED_0   = $00000400;  {1}
  LDTF_DEFAULT_BIG  = $00000200;  {1}
  LDTF_GRANULARITY  = $00000100;  {1}
  LDTF_BASEHI       = $000000FF;  {8}
 
 
type
  PLDTEntry = ^TLDTEntry;
  _LDT_ENTRY = record
    LimitLow: Word;
    BaseLow: Word;
    case Integer of
      0: (
        BaseMid: Byte;
        Flags1: Byte;
        Flags2: Byte;
        BaseHi: Byte);
      1: (
        Flags: Longint);
  end;
  {$EXTERNALSYM _LDT_ENTRY}
  TLDTEntry = _LDT_ENTRY;
  LDT_ENTRY = _LDT_ENTRY;
  {$EXTERNALSYM LDT_ENTRY}

Ah oui c'est un cas connu depuis 2007 au moins
et ici une belle démonstration pour encapsuler tout ça proprement

[Paul TOTH]

sur un Delphi moderne tu peux t'en sortir comme ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
type
  TLocalisation = packed record
  private
    bits: Word;
    function GetAltitude: Word;
    procedure SetAltitude(Value: Word);
    function GetBiome: Byte;
    procedure SetBiome(Value: Byte);
  public
    property Altitude:Word read GetAltitude write SetAltiture;
    property Biome: Byte read GetBiome write SetBiome; 
  end;

reste plus qu'à mettre à jour "bits"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
function TLocalisation.getAltitude: Word;
begin
  Result := bits and $FFF;
end;
 
procedure TLocation.SetAltitude(Value: Word);
begin
  bits := Value or (bits and  $F000);
end;
 
function TLocalisation.getBiome: Byte;
begin
  Result := bits shr 12;
end;
 
procedure TLocation.SetAltitude(Value: Byte);
begin
  bits := (Word(Value) shl 12) or (bits and  $FFF);
end;

[der§en]

Merci de votre aide, de mon coté, j'ai aussi créuser du même coté que Paul.

J'en était arrivé a ceci, que je vais comparer avec la solution de Paul:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
  TLocalisation = record
  private
    FContenu: Word;
    function  GetBiome: Word;
    procedure SetBiome(const AValue: Word);
    function  GetAltitude: Word;
    procedure SetAltitude(const AValue: Word);
  public
    property Biome: Word read GetBiome write SetBiome;
    property Altitude: Word read GetAltitude write SetAltitude;
  end;
 
function TLocalisation.GetBiome: Word;
begin
  Result := FContenu and $000F;
end;
 
procedure TLocalisation.SetBiome(const AValue: Word);
begin
  FContenu := AValue + (FContenu and $FFF0);
end;
 
function TLocalisation.GetAltitude: Word;
begin
  Result := (FContenu shr 4) and $0FFF;
end;
 
procedure TLocalisation.SetAltitude(const AValue: Word);
begin
  FContenu := (AValue shl 4) + (FContenu and $000F);
end;

A votre avis, j'ai commis des erreurs de calculs ?

[ShaiLeTroll]

Tu est parti sur un BigEndian au lieu de LittleEndian, ça fonctionnera mais inverser en mémoire