Discussion :

[Lorenzo77]

salut,

une petite question d'ordre général .


voici quelques déclarations de Math.Round du .NET Framework :

Code :

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

1
2
3
 
        public static decimal Round(decimal d, int decimals);
        public static decimal Round(decimal d, int decimals, MidpointRounding

je ne comprends pas l'utilisation de int decimals ... pourquoi déclarer un entier avec signe pouvant aller de -2 147 483 648 à 2 147 483 647 alors qu'un uint() ou encore mieux : un byte ferait parfaitement l'affaire ?


ne faut t'il pas utiliser le type qui limitera le plus le gaspillage d'espace ?

merci

[harz62]

je ne comprends pas l'utilisation de int decimals ... pourquoi déclarer un entier avec signe pouvant aller de -2 147 483 648 à 2 147 483 647 alors qu'un uint() ou encore mieux : un byte ferait parfaitement l'affaire ?

int est plus rapide qu'un byte.

[SaumonAgile]

Il se trouve qu'un int a exactement la taille optimale pour le système sur lequel il tourne, à savoir 32bits sur un système 32bits et 64bits sur un système 64bits. La taille d'un int dépend donc du système et le système possède des optimisations spécifique pour cette taille mémoire.

[StormimOn]

Intéressante question. Je me la suis posé récemment en plus ^^

Donc au final, il n'y a aucun intérêt à modifier le type sous-jascent sur les énumérations (int par défaut, et je comprends mieux pourquoi maintenant) ni à chercher à "optimiser" en typant au plus proche des valeurs attendues ? En général tout du moins car je suppose que dans certains cas cela apporte quelque chose.

[Guulh]

J'ajoute qu'en près de 2 ans de C#, j'ai jamais utilisé ni les short ni les long...

Pour un certain nombres d'applis (dans les 95% on va dire), se contenter des int suffit, ça évite notamment de devoir caster un long en int ou un int en short, au risque d'avoir une perte de précision.

[Lorenzo77]

merci pour les réponses, j'aurais du poser cette question avant

je viens de faire un test :

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
35
36
37
38
39
40
41
42
43
44
45
 
            Debug d = Debug.getRefDebug();
            Bench b = new Bench(5, 6, 1, true);
 
            b.benchDebut();
            for (uint a = 0; a < 10000000; a++)
            {
            }
            d.info("uint : " + b.benchFin());
 
            b.benchDebut();
            for (long a = 0; a < 10000000; a++)
            {
            }
            d.info("long : " + b.benchFin());
 
            b.benchDebut();
            for (int a = 0; a < 10000000; a++)
            {
            }
            d.info("int : " + b.benchFin());
 
            b.benchDebut();
            for (decimal a = 0; a < 10000000; a++)
            {
            }
            d.info("decimal : " + b.benchFin());
 
            b.benchDebut();
            for (double a = 0; a < 10000000; a++)
            {
            }
            d.info("double : " + b.benchFin());
 
            b.benchDebut();
            for (ulong a = 0; a < 10000000; a++)
            {
            }
            d.info("ulong : " + b.benchFin());
 
            b.benchDebut();
            for (float a = 0; a < 10000000; a++)
            {
            }
            d.info("float : " + b.benchFin());

résultat :
uint : 11,9016 Millieme
long : 11,951 Millieme
int : 9,7432 Millieme
decimal : 425,9553 Millieme
double : 37,9756 Millieme
ulong : 12,6518 Millieme
float : 19,6486 Millieme

certains types numérique sont vraiment plus rapide que d'autres, le int gagne !