Hello!

Inspiré(e) de prendre part à la discussion ? Ou de poser une question ou demander de l’aide ?

Alors bienvenues dans les grands sujets des forums de La Bulle : m’inscrire.

Cette partie du forum n’est pas compatible avec les bloqueurs publicitaires

Félicitations à vous, de préférer les accès payants plutôt que la gratuité par la publicité, c’est honnorable et cohérent de votre part. Malheureusement, l’accès payant par micropaiement (qui serait d’environ 1 cent pour 20 pages consultées) n’est pour l’instant pas encore mis en place, et l’accès gratuit sans publicité, est réservé aux membres actif(ve)s du forum. En attendant, si vous souhaitez poursuivre votre visite chez nous, vous pouvez ajouter le site à votre liste blanche, ou encore mieux, désactiver le bloqueur partout. Pour ajouter le site à votre liste blanche, pour Firefox (similaire pour les autres navigateurs), rendez‑vous en bas à gauche de la fenêtre de votre navigateur, et cliquez sur le menu comme dans l’exemple de l’image ci‑dessous, puis rechargez la page, en appuyant sur F5.

Interface d’un type de donnée : Représentation vs Interprétation
Auteur Message
Administrateur
Avatar de l’utilisateur
  • Genre : Télétubbie
  • Messages : 16232
Lun 6 Fév 2012 04:25
Message Interface d’un type de donnée : Représentation vs Interprétation
Discussion ouverte sur le cas concret d’une adresse IP.

La représentation est une liste ou tableau de 4 octets de 8 bits chacun. L’interprétation, si on pense aux masques CIDR (Classless InterDomain Routing), est un entier de 32 bits (4 * 8 bits).

L’interface du type de donnée devrait‑elle correspondre à la représentation ou à l’interprétation ? C’est finalement une colle.

Le représentation correspond naturellement à une interface standard, mais rend dans le cas présent, le type de donnée moins abstrait peut‑être (voir plus loin pourquoi). L’interprétation est plus adaptée au traitement, mais offre une interface peu naturelle est moins standard.

Exemple concret de l’un et de l’autre, en supposant d’abord définies les caractéristiques d’une adresse IP par les constantes et types suivants :

Octet dans le contexte du protocole IP :

Source Ada : 

package IPv4.Byte is
Number_Of_Bits : constant := 8;
type Instance_Type is mod 2 ** Number_Of_Bits;
end;


Spécification temporairement partielle pour l’adresse IP :

Source Ada : 

with IPv4.Byte;

package IPv4.Address is
Number_Of_Bytes : constant := 4;
Number_Of_Bits : constant := Number_Of_Bytes * Byte.Number_Of_Bits;
end;


En se basant sur la représentation, on peut définir l’adresse IP comme suit :

Source Ada : 

subtype Byte_Type is Byte.Instance_Type;
type Index_Type is range 1 .. Number_Of_Bytes;
type Instance_Type is array (Index_Type) of Byte_Type;


En se basant cette fois sur l’interprétation, on pourrait la définir comme suit :

Source Ada : 

type Instance_Type is mod 2 ** Number_Of_Bits;


On peut évidement ajouter une fonction au premier exemple :

Source Ada : 

function Representation (Instance : Instance_Type) return Representation_Type;


… ou ajouter une fonction au second example :

Source Ada : 

function Interpretation (Instance : Instance_Type) return Interpretation_Type;

Ceci supposant que Representation_Type et Interpretation_Type sont définis quelque part.

En résumé, deux possibilités.

  • Interface basée sur la représentation avec une fonction donnant l’interprétation.
  • Interface basée sur l’interprétation avec une fonction donnant la représentation.

Les deux solutions sont‑elles équivalentes ? L’une est‑elle plus légitime et plus propre que l’autre ?

Mais.

Il existe une troisième voie, celle d’un type de donnée purement abstrait, avec une fonction pour la représentation et une fonction pour l’interprétation.

Source Ada : 

type Instance_Type is private;
type Representation_Type is array (Index_Type) of Byte_Type;
type Interpretation_Type is mod 2 ** Number_Of_Bits;

function Representation
(Instance : Instance_Type)
return Representation_Type;

function Interpretation
(Instance : Instance_Type)
return Interpretation_Type;


Mais il faut alors définir un constructeur pour Instance_Type. Il pourrait être basé au choix…

…sur la représentation

Source Ada : 

function Create
(Representation : Representation_Type)
return Instance_Type;


… ou sur l’interprétation

Source Ada : 

function Create
(Interpretation : Interpretation_Type)
return Instance_Type;

… ou encore les deux Clin d’œil

Est‑ce celle‑ci la solution la plus propre et la mieux formalisée ?

L’exemple repose sur le cas concret d’une adresse IP, mais représente bien la question générale.

Personnellement, je trouve que la solution basée sur un type abstrait totalement opaque est la meilleure, mais ça m’emballerait bien d’avoir des opinions divergentes et de les peser.

Bien sûr, la question ne se pose pas pour tous les types de donnée, seulement pour ceux avec lesquels l’usage fait que leur représentation est autant présente dans les faits, que leur interprétation. Avec la plupart des types de données, la représentation s’efface devant l’interprétation. Il existe cependant des exceptions, dont l’adresse IP est un exemple. En connaissez‑vous d’autres exemples ? Si oui, ne vous privez pas de les partager ici Sourire doux .

Image
Hibou57

« La perversion de la cité commence par la fraude des mots » [Platon]
Profil Site Internet