Les nombres
Les nombres, en général, peuvent être divisés en deux types : le type entier et les types à virgule flottante. Les nombres de type entier sont des nombres entiers sans virgule décimale. Il peut s'agir de nombres négatifs ou positifs. Le type à virgule flottante est un nombre avec une ou plusieurs décimales. Il peut s'agir de nombres négatifs ou positifs. Le C# inclut différents types de données pour les types entiers et les types à virgule flottante en fonction de leur taille dans la mémoire et de leur capacité à entreposer des nombres.
Le schéma suivante illustre les types numériques en C# :
Types d'entiers
Les nombres de type entier sont des nombres entiers positifs ou négatifs sans points décimaux. Le C# inclut 4 types de données pour les nombres entiers : byte, short, int, et long.
byte
Le type de données byte entrepose des nombres de 0 à 255. Il occupe 8 bits dans la mémoire. Le mot clef byte est un alias de la structure Byte dans .NET. Le sbyte est identique à l'octet, mais il peut entreposer des nombres négatifs de -128 à 127. Le mot clef sbyte est un alias pour la structure SByte dans .NET.
Voici quelques exemples typiques de l'utilisation de ce type de données :
- using System;
- using System.Collections.Generic;
- using System.Linq;
- using System.Text;
-
- namespace ByteSamples
- {
- class Program
- {
- static void Main(string[] args)
- {
- byte myValue;
- myValue = 4;
- Console.WriteLine("myValue = " + myValue);
- myValue *= 2;
- Console.WriteLine("myValue = " + myValue);
- myValue++;
- Console.WriteLine("myValue = " + myValue);
- }
- }
- }
on obtiendra le résultat suivant :
myValue = 4myValue = 8
myValue = 9
Voici un exemple utilisant les limites du nombre :
- using System;
-
- public class Program {
- public static void Main() {
- byte b1 = 255;
- //byte b2 = -128; // erreur de compilation : la valeur constante '-128' ne peut pas être convertie en 'byte'
- sbyte sb1 = -128;
- sbyte sb2 = 127;
- Console.WriteLine(Byte.MaxValue);
- Console.WriteLine(Byte.MinValue);
- Console.WriteLine(SByte.MaxValue);
- Console.WriteLine(SByte.MinValue);
- }
- }
short
Le type de données court est un entier signé pouvant entreposer des nombres de -32 768 à 32 767. Il occupe une mémoire de 16 bits. Le mot clef short est un alias pour la structure Int16 dans .NET. Le type de données ushort est un entier non signé. Il ne peut entreposer que des nombres positifs de 0 à 65 535. Le mot clef ushort est un alias pour la structure UInt16 dans .NET.
Voici quelques exemples typiques de l'utilisation de ce type de données :
- using System;
- using System.Collections.Generic;
- using System.Linq;
- using System.Text;
-
- namespace UShortSamples
- {
- class Program
- {
- static void Main(string[] args)
- {
- ushort myValue;
- myValue = 4;
- Console.WriteLine("myValue = " + myValue);
- myValue *= 2;
- Console.WriteLine("myValue = " + myValue);
- myValue++;
- Console.WriteLine("myValue = " + myValue);
- }
- }
- }
on obtiendra le résultat suivant :
myValue = 4myValue = 8
myValue = 9
Voici un exemple utilisant les limites du nombre :
- using System;
-
- public class Program
- {
- public static void Main() {
- short s1 = -32768;
- short s2 = 32767;
- //short s3 = 35000; //erreur de compilation : la valeur constante « 35000 » ne peut pas être convertie en «short»
- ushort us1 = 65535;
- //ushort us2 = -32000; // erreur de compilation : la valeur constante '-32000' ne peut pas être convertie en «ushort»
- Console.WriteLine(Int16.MaxValue);
- Console.WriteLine(Int16.MinValue);
- Console.WriteLine(UInt16.MaxValue);
- Console.WriteLine(UInt16.MinValue);
- }
- }
int
Le type de données int est un entier signé 32 bits. Il peut entreposer des nombres de -2 147 483 648 à 2 147 483 647. Le mot clef int est un alias de la structure Int32 dans .NET. Le type de données uint est un entier non signé de 32 bits. Le mot clef uint est un alias de la structure UInt32 dans .NET. Il peut entreposer des nombres positifs de 0 à 4 294 967 295. Utilisez éventuellement le suffixe U ou u après un nombre pour l'affecter à la variable uint.
Le type de données int est également utilisé pour les nombres hexadécimaux et binaires. Un nombre hexadécimal commence par le préfixe 0x ou 0X. À partir de la version 7.2 de C#, un nombre binaire commence par 0b ou 0B.
Voici un exemple utilisant les limites du nombre :
- using System;
-
- public class Program
- {
- public static void Main() {
- int i = -2147483648;
- int j = 2147483647;
- //int k = 4294967294; // erreur de compilation : impossible de convertir implicitement le type « uint » en « int ».
- uint ui1 = 4294967295;
- //uint ui2 = -1; // erreur de compilation
- Console.WriteLine(Int32.MaxValue);
- Console.WriteLine(Int32.MinValue);
- Console.WriteLine(UInt32.MaxValue);
- Console.WriteLine(UInt32.MinValue);
- }
- }
long
Le type de données long correspond à des entiers signés 64 bits. Il peut entreposer des nombres de -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807. Utilisez le suffixe l ou L avec un numéro pour l'affecter à une variable de type de données long. Le mot clef long est un alias de la structure Int64 dans .NET.
Le type ulong entrepose les nombres positifs de 0 à 18 446 744 073 709 551 615. Si un nombre est suffixé par UL, Ul, uL, ul, LU, Lu, lU ou lu, son type de données est ulong. Le mot clef uint est un alias de la structure UInt64 dans .NET.
Voici un exemple utilisant les limites du nombre :
- using System;
-
- public class Program {
- public static void Main() {
- long l1 = -9223372036854775808;
- long l2 = 9223372036854775807;
- ulong ul1 = 18223372036854775808ul;
- ulong ul2 = 18223372036854775808UL;
- Console.WriteLine(Int64.MaxValue);
- Console.WriteLine(Int64.MinValue);
- Console.WriteLine(UInt64.MaxValue);
- Console.WriteLine(UInt64.MinValue);
- }
- }
Types à virgule flottante
Les nombres à virgule flottante sont des nombres positifs ou négatifs avec une ou plusieurs décimales. Le C# inclut trois types de données pour les nombres à virgule flottante : float, double et decimal.
float
Le type de données float peut entreposer des nombres fractionnaires de 3.4e-038 à 3.4e+038. Il occupe 4 octets dans la mémoire. Le mot clef float est un alias d'un structure Single dans .NET. Utilisez le suffixe f ou F avec un littéral pour le rendre de type flottant.
Cet exemple permet des déclarations de type de données float :
on obtiendra le résultat suivant :
Valeur de b=1.25Voici un exemple montrant quelques affectations :
double
Le type de données double peut entreposer des nombres fractionnaires de 1.7e-308 à 1.7e+308. Il occupe 8 octets dans la mémoire. Le mot clef double est un alias de la structure Double dans .NET. Utilisez le suffixe d ou D avec un littéral pour en faire un type de données double.
Cet exemple permet d'affecter une valeur à la variable «a» :
on obtiendra le résultat suivant :
a = 20.16Voici un exemple montrant quelques affectations :
decimal
Le type de données decimal peut entreposer des nombres fractionnaires de ±1,0 x 10-28 à ±7,9228 x 1028. Il occupe 16 octets dans la mémoire. La décimale est un alias de mot clef de la structure Decimal dans .NET. Le type décimal a plus de précision et une intervalle plus petite que float et double, et il est donc approprié pour les calculs financiers et monétaires. Utilisez le suffixe m ou M avec un littéral pour le rendre de type décimal.
Notation scientifique
Utilisez e ou E pour indiquer la puissance de 10 comme partie exposant de la notation scientifique avec float, double ou decimal :