Discussion :

[OutOfRange]

Bonjour

Je sèche sur une question basique
J'ai besoin de créer un nouveau type de variable, qui admettrait par exemple les valeurs entières 1,2,5,10,15,20 et seulement celles là

Code :

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

TMontype=1..20

ne convient pas : je ne veux pas des valeurs 3,4,6,7 etc.

Code :

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

TMontype=(1,2,5,10,20)

est incorrect

Si qqn a une idée

Merci d'avance

[Clorish]

Heuu juste comme ca :

Code :

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

TMonType = (mt1, mt2, mt5, mt10, mt15, mt20);

Avec les fonctions IntToMonType et MonTypeToInt qui vont bien ca peut le faire ...

Sinon tu peux utiliser d'autres solutions :

Code :

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

Var ValidNumber : Array[1..6] of Integer = (1, 2, 5, 10, 15, 20);

Avec des fonction IsValidNumber qui verifie si elle fait partie des valeurs du tableau.

[droggo]

Kio,

La solution plus simple est:

Code :

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

1
2
3
 
Type
  monType = (a1=1,a2=2,a5=5,a10=10,a20=20);

[Clorish]

En effet. Je ne savais pas que l'on pouvait avvecter une valeur precise a des constantes enumérés.

[Merlin]

Kio,

La solution plus simple est:

Code :

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

1
2
3
 
Type
  monType = (a1=1,a2=2,a5=5,a10=10,a20=20);

C'est certainement la solution la plus simple mais ça ne répond pas tout à fait à la question de départ à laquelle la réponse est tout simplement "non, c'est pas possible directement sous Delphi".
En effet, même avec un type énuméré dans lequel tu forces les valeurs comme dans ton exemple, rien n'interdit une variable de type "monType" de prendre la valer 12 (interdite pourtant) selon comment le code touche à cette variable et selon les éventuels contrôles / optimisations de compilation.

De fait, la réponse à est non, c'est pas possible car Delphi ne permet pas de créer de vrais types similaires aux types scalaires (entiers, chaînes, etc) à la différences de langages plus objets comme Java ou C#.

La seule façon de réponse proprement à la question est de créer une classe "monType", et non un énuméré, classe qui possède une property "LeNombre" qui, grace aux setter/getter va permettre de s'assurer que la valeur est toujours correcte.
Bien entendu, une variable de type "monType" ne sera pas directement utilisable comme un entier dans un calcul, il faudra ajouter une méthode du type AsInteger par ex qui retournera la valeur.
Tout le code s'en trouvera alourdi, mais c'est bien la seule solution qui répond au besoin fonctionnel (en partant du fait qu'on parle de delphi win32).

[sjrd]

Je suis assez d'accord avec Merlin. D'ailleurs, ceux qui ont lu mes interventions savent que je désapprouve le type de données pseudo-énuméré dans lequel on affecte des valeurs particulières.

En revanche, avec Delphi 2006 et plus, je complète la solution donnée par Merlin par l'utilisation de record avancé. Pour lequel on rend privée la donnée interne, et où l'on surcharge les conversions implicites et explicites vers le type entier.

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
type
  TValueType = Byte; // modifie ça comme tu veux
 
  TRestrictedValue = record
  private
    Value: TValueType;
  public
    class operator Implicit(AValue: TValueType): TRestrictedValue;
    class operator Implicit(const AValue: TRestrictedValue): TValueType; inline;
  end;
 
implementation
 
class operator TRestrictedValue.Implicit(AValue: TValueType): TRestrictedValue;
begin
  if not (AValue in [1, 2, 5, 10, 20]) then
    raise Exception.Create('Invalid value for TRestrictedValue');
  Value := AValue;
end;
 
class operator TRestrictedValue.Implicit(const AValue: TRestrictedValue): TValueType;
begin
  Result := AValue.Value;
end;

Code non testé.

Avec ça, les données de type TRestrictedValue s'utilisent exactement comme le type TValueType.

[droggo]

Jio,

Oui, je sais tout cela.

Dans tous les cas, quelle que soit la solution choisie, il faut implémenter des méthodes si on veut manipuler tout cela correctement, c'est à dire sans faille quel que soit le code (enfin, tant qu'il est logique !)).

[Merlin]

Je suis assez d'accord avec Merlin. D'ailleurs, ceux qui ont lu mes interventions savent que je désapprouve le type de données pseudo-énuméré dans lequel on affecte des valeurs particulières.

En revanche, avec Delphi 2006 et plus, je complète la solution donnée par Merlin par l'utilisation de record avancé.
...

Depuis D2006 la personnalité win32 permet en effet la surcharge des opérateurs par le biais du type "record" qui a été modifié.
Il y a un tuto de laurent dardenne sur ce sujet :
http://laurent-dardenne.developpez.c...rgeOperateurs/

[Tardiff Jean-François]

Bonjour,

il existe une possibilité simple.
C'est moyennement propre mais c'est efficace.

Code :

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

1
2
3
4
5
6
7
 
Type
Type
  TmonType = (a1,a2,a5,a10,a20);
Const
Type
  TmonTypeString : Array [TmonType] of Integer = (1, 2, 5, 10, 20);

en fait il s'agit d'établir une table de conversion entre TMonType et la valeur de TMonType

a1 = 1
TmonTypeString[a1] = 1

a2 = 2
TmonTypeString[a2] = 2

a3 = 3
TmonTypeString[a3] = 3

a5 = 4
TmonTypeString[a5] = 5

a10 = 5
TmonTypeString[a10] = 10

[Merlin]

Bonjour,
il existe une possibilité simple.
C'est moyennement propre mais c'est efficace.

Cela ne répond pas réellement à la demande. Un astuce pour faire correspondre un énuméré à un integer, il y a même beaucoup plus simple que ta solution, cela a été proposé dans le fil ici (en assignant directement les integer à chaque élément lors de la déclaration de l'énuméré).
Mais tout cela n'est que bricolage puisque le but d'un type dans un langage fortement typé, ce que revendique Delphi, et ce que souhaitait notre ami au départ, c'est bien qu'il soit impossible par code d'écrire variable := 12 si la valeur 12 est interdite, et que cette détection ne soit pas seulement une erreur runtime (ce qui serait possible avec les solutions d'une classe ou celle d'un record aussi proposées) mais bien une erreur de compilation. De la même façon que l'affectation d'un string à une variable integer ne passe pas la compilation.
Là on retrouverait la notion de type dans un environnement fortement typé. Mais cela reste impossible sous Delphi en tout cas.