Partager via

Types de données numériques (Visual Basic)

Visual Basic fournit plusieurs types de données numériques pour la gestion des nombres dans différentes représentations. Les types intégraux représentent uniquement des nombres entiers (positifs, négatifs et zéro), et les types non intégrés représentent des nombres avec des parties entières et fractionnaires.

Pour obtenir un tableau montrant une comparaison côte à côte des types de données Visual Basic, consultez Types de données.

Types numériques intégraux

Les types de données intégraux sont ceux qui représentent uniquement des nombres sans parties fractionnaires.

Les types de données intégral signés sont le type de données SByte (8 bits), le type de données court (16 bits), le type de données entier (32 bits) et le type de données long (64 bits). Si une variable stocke toujours des entiers plutôt que des nombres fractionnaires, déclarez-la comme l’un de ces types.

Les types intégraux non signés sont le type de données Byte (8 bits), le type de données UShort (16 bits), le type de données UInteger (32 bits) et le type de données ULong (64 bits). Si une variable contient des données binaires ou des données de nature inconnue, déclarez-la comme l’un de ces types.

Performances

Les opérations arithmétiques sont plus rapides avec les types intégraux qu’avec d’autres types de données. Ils sont les plus rapides avec les Integer types et UInteger les types en Visual Basic.

Entiers volumineux

Si vous devez contenir un entier supérieur à celui que le Integer type de données peut contenir, vous pouvez utiliser le type de données à la Long place. Long les variables peuvent contenir des nombres compris entre -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807. Les opérations avec Long sont légèrement plus lentes que avec Integer.

Si vous avez besoin de valeurs encore plus grandes, vous pouvez utiliser le type de données décimal. Vous pouvez contenir des nombres compris entre -79 228 162 514 264 337 593 543 950 335 à 79, 228 162 514 264 337 593 543 950 335 dans une Decimal variable si vous n’utilisez pas de décimales. Toutefois, les opérations avec Decimal des nombres sont considérablement plus lentes qu’avec n’importe quel autre type de données numérique.

Entiers petits

Si vous n’avez pas besoin de la plage complète du type de données, vous pouvez utiliser le Short type de Integer données, qui peut contenir des entiers compris entre -32 768 et 32 767. Pour la plus petite plage d’entiers, le SByte type de données contient des entiers de -128 à 127. Si vous avez un très grand nombre de variables qui contiennent de petits entiers, le Common Language Runtime peut parfois stocker vos Short variables de SByte manière plus efficace et économiser la consommation de mémoire. Toutefois, les opérations avec Short et SByte sont un peu plus lentes que avec Integer.

Entiers non signés

Si vous savez que votre variable n’a jamais besoin de contenir un nombre négatif, vous pouvez utiliser les types Bytenon signés, UShort, UIntegeret ULong. Chacun de ces types de données peut contenir un entier positif deux fois plus grand que son type signé correspondant (SByte, , ShortIntegeret Long). En termes de performances, chaque type non signé est exactement aussi efficace que son type signé correspondant. En particulier, UInteger les partages avec Integer la distinction d’être le plus efficace de tous les types de données numériques élémentaires.

Types numériques nonintegral

Les types de données nonintegral sont ceux qui représentent des nombres avec des parties entières et fractionnaires.

Les types de données numériques non intégré sont Decimal (point fixe 128 bits), type de données unique (virgule flottante 32 bits) et type de données double (virgule flottante 64 bits). Ils sont tous des types signés. Si une variable peut contenir une fraction, déclarez-la comme l’un de ces types.

Decimal n’est pas un type de données à virgule flottante. Decimal les nombres ont une valeur entière binaire et un facteur de mise à l’échelle entier qui spécifie la partie de la valeur est une fraction décimale.

Vous pouvez utiliser des Decimal variables pour les valeurs monétaires. L’avantage est la précision des valeurs. Le Double type de données est plus rapide et nécessite moins de mémoire, mais il est soumis à des erreurs d’arrondi. Le Decimal type de données conserve la précision complète à 28 décimales.

Les nombres à virgule flottante (Single et Double) ont des plages supérieures à celles des Decimal nombres, mais peuvent être soumis à des erreurs d’arrondi. Les types à virgule flottante prennent en charge moins de chiffres significatifs que Decimal mais peuvent représenter des valeurs de plus grande ampleur.

Les valeurs de nombre nonintegral peuvent être exprimées sous forme de mmmEeee, dans laquelle mmm est la mantisse (les chiffres significatifs) et eee est l’exposant (puissance de 10). Les valeurs positives les plus élevées des types nonintegral sont 7,922816251426433759354395335E+28 pour Decimal, 3.4028235E+38 pour Single, et 1.79769313486231570E+308 pour Double.

Performances

Double est le plus efficace des types de données fractionnaires, car les processeurs sur les plateformes actuelles effectuent des opérations à virgule flottante en double précision. Toutefois, les opérations avec Double ne sont pas aussi rapides qu’avec les types intégraux tels que Integer.

Petites grandeurs

Pour les nombres ayant la plus petite magnitude possible (proche de 0), Double les variables peuvent contenir des nombres aussi petits que -4,94065645841246544E-324 pour les valeurs négatives et 4,9406564584124654E-324 pour les valeurs positives.

Petits nombres fractionnels

Si vous n’avez pas besoin de la plage complète du type de données, vous pouvez utiliser le Single type de Double données, qui peut contenir des nombres à virgule flottante de -3,4028235E+38 à 3,4028235E+38. Les plus petites magnitudes pour Single les variables sont -1,401298E-45 pour les valeurs négatives et 1,401298E-45 pour les valeurs positives. Si vous avez un très grand nombre de variables qui contiennent de petits nombres à virgule flottante, le Common Language Runtime peut parfois stocker vos Single variables plus efficacement et économiser la consommation de mémoire.

Voir aussi