Discussion :

[Vilukariok]

Bonjour,

Je voulais transformer un "Word" en "Array of Byte".
Et je suis tomber la dessus.
(Issue de l'aide de Delphi)

-------------
Pascal

Code :

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

1
2
3
4
5
6
WordRec = packed record
  case Integer of
    0: (Hi: Byte;
        Lo: Byte;);
    1: (Bytes: array [0..1] of Byte););
end;

Fichier
SysUtils
--------

Utilisation:

Code :

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

1
2
Data[0]:= WordRec(Value).Lo;
Data[1]:= WordRec(Value).Hi;

Diantre, je ne comprend absolument pas cette écriture???
Un case de Integer ?
Si quelqu'un a une idée?
Merci

[ShaiLeTroll]

C'est l'équivalent Delphi des union struct du C++
Partie variable des enregistrements


Pour résumer Hi et Lo partage le même espace mémoire que Bytes[0] et Bytes[1]

[Dr.Who]

Oui, en fait dans un record, quand on déclare un case of (qui pourrait être integer, word ou byte, cela n'as pas d'importance pour le moment) c'est comme si nous créions des "tiroirs" virtuels sur chaque octets de l'espace mémoire utilisé par le case of, qui, pourrait être vulgairement décrit comme un élément "non nommé" de record.

pour cela il faut bien comprend les Registres en assembleur, ça aide, puisque c'est le même concept de lecture/ecriture (quand on travail sur EAX, AX, AH et HL)

on pourrait même écrire ceci :

Code :

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

1
2
3
4
5
6
7
8
9
TUnPaquet = packed record
  case integer of
    0: (LW: LongWord);
    1: (W1,W2: word);
    2: (B1,B2,B3,B4: byte);
    3: (aW: array[0..1] of word);
    4: (aB: array[0..3] of byte);
    5: (aC: array[0..3] of AnsiChar);
end;

LW est un entier non signé 32bit (4 octets)
W1, W2 et aW sont des entiers non signé 16bits (2 octets) qui partagerons respectivement le même bloc mémoire que LW (4 octets)
B1 à B4 et aB sont des entiers non signé 8bits (1 octets) qui auront la même particularité que W1, W2 et aW.
aC sont des caractères ansi, équivalent à des entiers non signé 8bits.

découpage du bloc mémoire pour TUnPaquet:

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
 
TUnPaquet    [00|00|00|00] = 32bits = 4 octets (bytes)
octets       [ 1| 2| 3| 4]
 
LW           [00|00|00|00]   // bloc complet 
W1 ou aW[1]  [00|00]         // partie haute du bloc
W2 ou aW[0]        [00|00]   // partie basse du bloc
B1 ou aB[3]  [00]
B2 ou aB[2]     [00]
B3 ou aB[1]        [00]
B4 ou aB[0]           [00]
aC[3]        [00]
aC[2]           [00]
aC[1]              [00]
aC[0]                 [00]
 
 
en comparaison avec un registre 32bits :
 
EAX [00|00|00|00]  
AX        [00|00]   
AH        [00]
AL           [00]

[fab256]

Discussion déja entamée dans le forum pour la partie Record Packed. ici
Je rajouterai juste que le mot clé Packed devant le record veut dire minimiser l'espace mémoire pris par l'objet.

Normalement, les types de données complexes, comme les record ont leurs éléments alignés a 2, 4 ou 8 octets, selon le type de données. Par exemple un Word va être aligné sur 4 octets. L'alignements permet des performances d'accès optimale.

Le mot clé Packed, comprime les données a la plus petite taille avec comme conséquence une réduction des performances d'accès.

[CapJack]

Oui, le "case integer of" dans un record (partie variante d'un enregistrement) est peu connu...

Sans vouloir rien affirmer de façon péremptoire, il me semble bien que ça fait partie de la sémantique du langage Pascal depuis ses origines.

J'ai cherché la référence chez N. Wirth itself, mais je ne tombe que sur des articles payants. Si quelqu'un peut confirmer que c'était déjà dans la version 1971...

C'était prévu au départ pour stocker des enregistrements pouvant avoir différentes formes dans un même fichier, en faisant utiliser le même "espace mémoire" (vu de façon abstraite) par les différentes formes que pouvait prendre l'enregistrement. Dans les années '60/'70, les octets coûtaient chers, et donc étaient précieux.

Maintenant, s'en servir pour accéder aux octets d'une variable est une astuce souvent utilisée, mais ce n'était pas fait pour ça au départ. Et ça rend le programme dépendant de l'implémentation.

Pour le "packed", j'ai rien à ajouter à ce qui a déjà été rappelé.

[tourlourou]

parmi les petites astuces pour interpréter différemment un type de variable, on peut utiliser la directive absolute qui fait pointer une seconde variable de type différent sur le même espace mémoire qu'une première :

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
type 
  TWordRec = packed record
    Hi: Byte;
    Lo: Byte;
  end;
 
  TBytes: array [0..1] of Byte);
 
var
  Mot : Word;  
  WordRec: TWordRec; absolute Mot;
  Bytes: TBytes; absolute Mot;
 
begin
  Mot:=$FFFF; // comme ça, pas de problème ;-)
  if WordRec.Hi=Bytes[0] then ShowMessage'Bingo');
end;

[CapJack]

Pour en revenir aux parties variantes d'un record, et aux "tag fields" (j'ai découvert le terme), j'ai quand même fini par mettre la main sur une version scannée de l'article de Niklaus Wirth "The Programming Language Pascal" paru dans Acta Informatica, Vol. 1, Fasc. 1, en 1971. Et bingo :



Mes souvenirs ne m'avaient pas trompé, je ne suis pas encore complètement gâteux.

Edit : j'ai oublié le lien pour la référence : http://www-sst.informatik.tu-cottbus...Wirth_hist.pdf