Discussion :

[oodini]

Hello,

Je voudrais qu'une valeur ne puisse prendre que les valeurs 1, 2, ou 3.

Les enums ont besoin d'identifiants pour chaque valeurs.

Or, je n'ai pas besoin d'identifiants. Je veux seulement qu'un entier puisse recevoir un certain nombre de valeurs. Comment faire ?

[Bluedeep]

Or, je n'ai pas besoin d'identifiants. Je veux seulement qu'un entier puisse recevoir un certain nombre de valeurs. Comment faire ?

Utiliser un enum : qui peut le plus peut le moins.

Sur les persistences SGBD, il existe un moyen de contraindre des plages de valeurs sur un type, mais pas dans les langages de programmation en général.(il y a surement des exceptions).

On peut décrire te demande autrement :
un int est par définition une structure qui peut prendre toutes les valeurs entre (-2^31) + 1 et (2^31) - 1.
Donc si tu veux quelque chose qui prend les valeurs 1,2,3 ce n'est pas un entier dont tu as besoin, mais "quelque chose" pouvant prendre les valeurs 1,2,3; c'est précisément l'usage de l'enum.

[oodini]

Donc si tu veux quelque chose qui prend les valeurs 1,2,3 ce n'est pas un entier dont tu as besoin, mais "quelque chose" pouvant prendre les valeurs 1,2,3; c'est précisément l'usage de l'enum.

Certes, mais comment l'implémenter ?

Code :

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

1
2
enum pouet { _1=1, _2, _3 }
pouet = 2;

?

[ctxnop]

Certes, mais comment l'implémenter ?

Code :

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

1
2
enum pouet { _1=1, _2, _3 }
pouet = 2;

?

plutot comme ca :

Code :

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

1
2
3
4
5
 
enum pouet{ un = 1, deux, trois }
 
pouet a = pouet.un;
pouet b = (pouet)2;

[hegros]

L'enum est le plus approprié, après tu peux toujours monter un système d'exception mais bon c'est juste pour s'arracher un peu les cheveux de la tête que je te donne un exemple

Code :

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

1
2
3
enum Entier {One=1,Two };
 
int i = (int)Entier.One;

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
 
class X
		{
 
			List<int> ValeursValides = new  List<int>() { 1,2,3 };
			int _MonEntier;
			public int MonEntier
			{
				get {return _MonEntier;}
				set
				{
					bool valide = Convert.ToBoolean(
										(from valeursvalides in ValeursValides
					               where valeursvalides == value
					               select valeursvalides).Count()
					);
 
					if (!valide)
					{
						throw new Exception("valeur " + value + " invalide");
					}
					else
					{
						_MonEntier = value;		
 
					}
 
 
				}
			}
		}

[oodini]

Code :

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

1
2
3
enum Entier {One=1,Two };
 
int i = (int)Entier.One;

OK. C'est ce à quoi j'avais pensé, mais je voulais savoir s'il y avait moyen d'éviter ces identifiants factices.

Merci.

[hegros]

OK. C'est ce à quoi j'avais pensé, mais je voulais savoir s'il y avait moyen d'éviter ces identifiants factices.

Merci.

Beh non c'est la valeur associée à un élément de ton enum. Sinon comment savoir que la valeur de l'int 'One' commence à 0 ou 1 ou autre chose ?

Edit : quoi que si la valeur du premier est 0

Code :

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

enum Entier { Zero, Un, Deux, Trois };

[Bluedeep]

L'enum est le plus approprié, après tu peux toujours monter un système d'exception mais bon c'est juste pour s'arracher un peu les cheveux de la tête que je te donne un exemple

Dans ce cas on peut faire beaucoup plus joli et général. (avec la "magie" du mot clef "implicit" ).

Exemple :

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
    class ConstraintInt
    {
        private static int _min =  1;
        private static int _max =  3;
        private int _value;
        private ConstraintInt(int value)
        {
            _value = value;
        }
        public static implicit operator ConstraintInt(int i)
        {
            if (i < _min || i > _max)
            {
                throw new Exception("Pas dans la plage attendu");
            }
            return new ConstraintInt(i);
        }
 
        public static implicit operator int(ConstraintInt c)
        {
            return c._value;
        }
    }

Puis tu exploites ainsi :

Code :

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

1
2
3
4
5
6
        public static void Test()
        {
            ConstraintInt c1 = 1; // OK
            ConstraintInt c2 = c1 + 1; // OK
            ConstraintInt c3 = 10; // Exception !
        }

PLus sympa, non ?

On peut même faire un truc de base ConstraintInt et une classe héritée qui via un attribut custom préciserait la plage attendue.

[hegros]

PLus sympa, non ?

Carrément plus sympa même

hegros dans ton exemple, ca serait peut être mieux de faire ainsi :

Carrément même

J'avais bien préciser pour s'arracher les cheveux pas pour faire élégant ou simple