importance de donner le bon type

Version imprimable

21/08/2008, 13h37
Lorenzo77

importance de donner le bon type
salut,

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

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

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
21/08/2008, 13h51
harz62

Citation:

Envoyé par Lorenzo77

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.
21/08/2008, 14h07
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.
21/08/2008, 14h31
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.
21/08/2008, 14h43
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.

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

je viens de faire un test :

Code:

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 8O
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 !