Langage de programmation - C# (C Sharp) - Types primitifs et variables

Types primitifs et variables

Les types primitifs sont les types de données élémentaires suivants : bool, ushort, uint, int, ulong, long, byte, sbyte, float, double, decimal et char. Ces types primitifs correspondent aux classes Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double et Single. Ainsi, on peut donc traiter les types primitifs comme des objets en utilisant le tableau de référence suivant :

Type primitif	Classe correspondante
bool	Boolean
byte	Byte
sbyte	SByte
char	Char
short	Int16
int	Int32
long	Int64
ushort	UInt16
uint	UInt32
ulong	UInt64
float	Single
double	Double
decimal	Decimal

Qu'est-ce qu'une variable ?

Un programme typique utilise diverses valeurs changeant pendant son exécution. Par exemple, nous créons un programme effectuant des calculs sur les valeurs saisies par l'utilisateur. Les valeurs saisies par un utilisateur seront évidemment différentes de celles saisies par un autre utilisateur. Cette situation signifie que lors de la création du programme, le programmeur ne sait pas quelles valeurs seront introduites en entrée, et cela rend nécessaire de traiter toutes les valeurs possibles qu'un utilisateur peut entrer. Lorsqu'un utilisateur entre une nouvelle valeur étant utilisée dans le processus de calcul, nous pouvons la conserver (temporairement) dans la mémoire vive de notre ordinateur. Les valeurs de cette partie de la mémoire changent (varient) tout au long de l'exécution et cela a conduit à leur nom : variables.

Types de données

Les types de données sont des ensembles (intervalles) de valeurs ayant des caractéristiques similaires. Par exemple, le type d'octet spécifie l'ensemble des nombres entiers compris entre [0...255]. Les types de données sont caractérisés par : leur nom (par exemple, int), leur taille (combien de mémoire ils utilisent, par exemple, 4 octets) et leur valeur (par défaut, par exemple 0). Les types de données de base en C# sont répartis dans les types suivants :

Catégorie	Types de données
Types entiers	sbyte, byte, short, ushort, int, uint, long, ulong
Types réels à virgule flottante	float, double
Type réel avec précision décimale	decimal
Type booléen	bool
Type de caractère	char
Chaîne de caractères	string
Type d'objet	object

Ces types de données sont appelés primitifs (types intégrés), car ils sont incorporés dans le langage de programmation C# au niveau le plus bas. Le tableau suivant représente les types de données mentionnés ci-dessus, leur intervalles et leurs valeurs par défaut :

Types de données	Valeur par défaut	Valeur minimum	Valeur maximum
sbyte	0	-128	127
byte	0	0	255
short	0	-32768	32767
ushort	0	0	65535
int	0	-2147483648	2147483647
uint	0u	0	4294967295
long	0L	-9223372036854775808	9223372036854775807
ulong	0u	0	18446744073709551615
float	0.0f	±1.5×10-45	±3.4×1038
double	0.0d	±5.0×10-324	±1.7×10308
decimal	0.0m	±1.0×10-28	±7.9×1028
bool	false	Deux valeurs possibles : true et false
char	'\u0000'	'\u0000'	'\uffff'
object	null	-	-
string	null	-	-

Correspondance entre les types C# et .NET

Les types de données primitifs en C# ont une correspondance directe avec les types du système de type commun (CTS) dans le cadre d'application .NET. Par exemple, le type int en C# correspond au type System.Int32 en CTS et au type Integer en langage de programmation VB.NET, tandis que le type long en C# correspond au type System.Int64 en CTS et au type Long en langage de programmation VB.NET. En raison du système de types communs (CTS) dans le cadre d'application .NET, il existe une compatibilité entre différents langages de programmation (comme par exemple, C#, Managed C++, VB.NET et F#). Pour la même raison, les types int, Int32 et System.Int32 en C# sont en fait des alias différents pour un seul et même type de données - un entier de 32 bits signé.

Types entiers

Les types entiers représentent des nombres entiers et sont sbyte, byte, short, ushort, int, uint, long et ulong. Examinons-les un par un. Le type sbyte est un entier signé de 8 bits. Cela signifie que le nombre de valeurs possibles est de 2⁸, soit 256 valeurs au total, et elles peuvent être à la fois positives et négatives. La valeur minimale pouvant être entreposée dans sbyte est SByte.MinValue = -128 (-2⁷) et la valeur maximale est SByte.MaxValue = 127 (2⁷-1). La valeur par défaut est le nombre 0. Le type d'octet est un type entier non signé 8 bits. Il a également 256 valeurs entières différentes (2⁸) ne pouvant être que non négatives. Sa valeur par défaut est le nombre 0. La valeur minimale prise est Byte.MinValue = 0 et la valeur maximale est Byte.MaxValue = 255 (2⁸-1). Le type short est un entier signé 16 bits. Sa valeur minimale est Int16.MinValue = -32768 (-2¹⁵) et la valeur maximale est Int16.MaxValue = 32767 (2¹⁵-1). La valeur par défaut du type short est le nombre 0. Le type ushort est un entier non signé de 16 bits. La valeur minimale qu'il peut entreposer est UInt16.MinValue = 0 et la valeur minimale est UInt16.MaxValue = 65535 (2¹⁶-1). Sa valeur par défaut est le nombre 0. Le prochain type entier que nous considérerons est int. C'est un entier signé de 32 bits. Comme nous pouvons le constater, la croissance des bits augmente les valeurs possibles qu'un type peut entreposer. La valeur par défaut de int est 0. Sa valeur minimale est Int32.MinValue = -2 147 483 648 (-2³¹) et sa valeur maximale est Int32.MaxValue = 2 147 483 647 (2³¹-1). Le type int est le type le plus souvent utilisé en programmation. Habituellement, les programmeurs utilisent int lorsqu'ils travaillent avec des entiers car ce type est naturel pour le microprocesseur 32 bits et est suffisamment gros pour la plupart des calculs effectués dans la vie quotidienne. Le type uint est de type entier non signé 32 bits. Sa valeur par défaut est le nombre 0u ou 0U (les deux sont équivalents). La lettre «u» indique que le nombre est de type uint (sinon, il est compris comme int). La valeur minimale qu'il peut prendre est UInt32.MinValue = 0 et la valeur maximale est UInt32.MaxValue = 4 294 967 295 (2³²-1). Le type long est un type signé 64 bits avec une valeur par défaut de 0l ou 0L (les deux sont équivalents mais il est préférable d'utiliser 'L' car la lettre 'l' est facilement confondue avec le chiffre un '1'). La lettre 'L' indique que le nombre est de type long (sinon il est compris int). La valeur minimale pouvant être entreposée dans le type long est Int64.MinValue = -9 223 372 036 854 775 808 (-2⁶³) et sa valeur maximale est Int64.MaxValue = 9 223 372 036 854 775 807 (2⁶³-1). Le plus grand type entier est le type ulong. C'est un type non signé de 64 bits, ayant comme valeur par défaut - le nombre 0u ou 0U (les deux sont équivalents). Le suffixe «u» indique que le nombre est de type ulong (sinon il est entendu comme long). La valeur minimale pouvant être enregistrée dans le type ulong est UInt64.MinValue = 0 et la valeur maximale est UInt64.MaxValue = 18 446 744 073 709 551 615 (2⁶⁴-1). Prenons un exemple dans lequel nous déclarons plusieurs variables des types entiers que nous connaissons, nous les initialisons et affichons leurs valeurs sur la console :



using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 
namespace integersamples

{

    class Program

    {

        static void Main(string[] args)

        {

            byte siecle = 20;

            ushort annees = 2020;

            uint jours = 737300;

            ulong heures = 17695200;

 
            Console.WriteLine("Au " + siecle + " siècle, dans l'année " + annees + ", soit " + jours + " jours, ou " + heures + " heures.");

 
            ulong maxIntValue = UInt64.MaxValue;

            Console.WriteLine(maxIntValue);

        }

    }

}

Types de données réels à virgule flottante

Les types réels en C# sont les nombres réels comme nous les connaissons grâce dans les sciences des mathématiques. Ils sont représentés par une virgule flottante selon la norme IEEE 754 et sont float et double. Examinons en détail ces deux types de données et comprenons quelles sont leurs similitudes et leurs différences.

Type réel Float

Le premier type que nous considérerons est le type de données à virgule flottante réel de 32 bits. Il est également connu sous le nom de nombre réel à de simple précision. Sa valeur par défaut est 0,0f ou 0,0F (les deux sont équivalents). Le caractère 'f' lorsqu'il est placé à la fin indique explicitement que le nombre est de type float (car par défaut tous les nombres réels sont considérés comme double). Le type considéré a une précision jusqu'à sept décimales (les autres sont perdues). Par exemple, si le nombre 0.123456789 est entreposé sous le type float, il sera arrondi à 0.1234568. L'intervalle de valeurs, pouvant être incluse dans un type de données à virgule flottante (arrondi avec une précision de 7 chiffres décimaux significatifs), va de ±1,5 × 10^-45 à ±3,4 × 10³⁸. Les types de données réels ont également plusieurs valeurs spéciales n'étant pas des nombres réels mais sont des abstractions mathématiques :

Infini négatif -∞ (Single.NegativeInfinity). Il est obtenu lorsque, par exemple, nous divisons -1,0f par 0,0f.
Infini positif +∞ (Single.PositiveInfinity). Il est obtenu lorsque, par exemple, nous divisons 1,0f par 0,0f.
Incertitude (Single.NaN) - signifie qu'une opération invalide est effectuée sur des nombres réels. Il est obtenu lorsque, par exemple, nous divisons 0,0f par 0,0f, ainsi que lors du calcul de la racine carrée d'un nombre négatif.

Type de données réel Double

Le deuxième type de donnée réel à virgule flottante dans le langage de programmation C# est le type de donnée double. Il est également appelé nombre réel de double précision et est de type de 64 bits avec une valeur par défaut de 0,0d et 0,0D (le suffixe 'd' n'est pas obligatoire car par défaut tous les nombres réels en C# sont de type de donnée double). Ce type de donnée a une précision de 15 à 16 chiffres décimaux. L'intervalle de valeurs, pouvant être enregistrée en double (arrondie avec une précision de 15 à 16 chiffres décimaux significatifs), va de ± 5,0 × 10^-324 à ± 1,7 × 10³⁰⁸. La plus petite valeur réelle de type de données double est la constante Double.MinValue = -1,79769e+308 et la plus grande est Double.MaxValue = 1,79769e+308. Le nombre positif le plus proche de 0 de type de données double est Double.Epsilon = 4.94066e324. Comme pour le type de donnée float, les variables de type de données double peuvent prendre les 116 principes fondamentaux de la programmation informatique spéciaux avec des valeurs C# : Double.PositiveInfinity (+∞), Double.NegativeInfinity (-∞) et Double.NaN (nombre invalide). Voici un exemple dans lequel nous déclarons des variables de types de nombres réels, leur attribuons des valeurs et les affichons :



using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 
namespace RealSamples

{

    class Program

    {

        static void Main(string[] args)

        {

            float floatPI = 3.14159f;

            Console.WriteLine(floatPI); // Nombre 3,14159

            double doublePI = 3.14159;

            Console.WriteLine(doublePI); // 3,14159

            double nan = Double.NaN;

            Console.WriteLine(nan); // NaN

            double infinity = Double.PositiveInfinity;

            Console.WriteLine(infinity); // Infini

        }

    }

}

Précision des types de données réels

En mathématiques, les nombres réels dans une intervalles donnée sont innombrables (par opposition aux nombres entiers de cette intervalle) car entre deux nombres réels a et b, il y a d'innombrables autres nombres réels c où a < c < b. Cette situation nécessite que les nombres réels soient entreposés dans la mémoire de l'ordinateur avec une précision limitée. Puisque les mathématiques et la physique fonctionnent principalement avec des nombres extrêmement grands (positifs et négatifs) et avec des nombres extrêmement petits (très proches de zéro), les types de données réels dans les périphériques informatiques et électroniques doivent être entreposés et traités de manière appropriée. Par exemple, selon la physique, la masse de l'électron est d'environ 9,109389 × 10^-31 kilogrammes et dans 1 mole de substance, il y a environ 6,02 × 10²³ atomes. Ces deux valeurs peuvent être stockées facilement dans les types float et double. En raison de sa flexibilité, la représentation moderne en virgule flottante des nombres réels nous permet de travailler avec un nombre maximum de chiffres significatifs pour de très grands nombres (par exemple, des nombres positifs et négatifs avec des centaines de chiffres) et avec des nombres très proches de zéro (par exemple, des nombres positifs et négatifs avec des centaines de zéros après la virgule décimale avant le premier chiffre significatif). Les nombres réels à virgule flottante en C # se composent de trois composants (selon la norme IEEE 754): signe (1 ou -1), mantisse et ordre (exposant), et leurs valeurs sont calculées par une formule complexe. Dans les calculs avec des types de données réels à virgule flottante, il est possible d'observer un comportement étrange, car lors de la représentation d'un nombre réel donné, il arrive souvent à perdre en précision. La raison en est l'incapacité de certains nombres réels à être représentés exactement comme une somme de puissances négatives du nombre 2. De plus, tous les nombres réels n'ont pas une représentation précise dans les types float et double. Par exemple, le nombre 0,1 est représenté arrondi en type float comme 0,099999994.

Types réels avec précision décimale

Le langage de programmation C# prend en charge l'arithmétique dite décimale à virgule flottante, où les nombres sont représentés via le système numérique décimal plutôt que le système binaire. Ainsi, le type arithmétique décimal à virgule flottante en C# ne perd pas de précision lors de l'entreposage et du traitement des nombres à virgule flottante. Le type de données pour les nombres réels avec une précision décimale en C# est le type décimal de 128 bits. Il a une précision de 28 à 29 décimales. Sa valeur minimale est -7,9 × 1028 et sa valeur maximale est + 7,9 × 1028. La valeur par défaut est 0,0 m ou 0,0 m. Le caractère 'm' à la fin indique explicitement que le nombre est de type décimal (car par défaut tous les nombres réels sont de type double). Les nombres les plus proches de 0, pouvant être enregistrés en décimal, sont ± 1,0 × 10^-28. Il est évident que le décimal ne peut entreposer ni de très gros nombres positifs ou négatifs (par exemple, avec des centaines de chiffres), ni des valeurs très proches de 0. Cependant, ce type est presque parfait pour les calculs financiers car il représente les nombres comme une somme de puissances de 10 et les pertes d'arrondi sont beaucoup plus petites que lors de l'utilisation de la représentation binaire. Les nombres réels de type décimal sont extrêmement pratiques pour les calculs financiers - calcul des revenus, droits, taxes, intérêts, paiements,...

Type de données booléen

Le type de données booléen est déclaré avec le mot clef bool. Il a deux valeurs possibles : true et false. Sa valeur par défaut est false. Il est le plus souvent utilisé pour entreposer le résultat du calcul des expressions logiques. On l'utilise également pour entreposer des résultats d'opérateur ternaire.

Type de données de caractère

Le type de données caractère est un caractère unique (numéro 16 bits d'un caractère de table Unicode). Il est déclaré en C# avec le mot-clef char. La table Unicode est un standard technologique représentant n'importe quel caractère (lettre, ponctuation,...) de toutes les langues humaines en tant que systèmes d'écriture (toutes langues et alphabets) avec un entier ou une séquence d'entiers. La plus petite valeur possible d'une variable char est 0 et la plus grande est 65535. Les valeurs de type char sont des lettres ou d'autres caractères et sont entourées d'apostrophes.

Les chaînes de caractères

Les chaînes de caractères sont des séquences de caractères. En C#, ils sont déclarés par le mots-clefs string. Leur valeur par défaut est null. Les chaînes de caractères sont placées entre doubles guillemets. Différentes opérations de traitement de texte peuvent être effectuées à l'aide de chaînesde caractères : concaténation (jonction d'une chaîne de caractères à une autre), fractionnement par un séparateur donné, recherche, remplacement de caractères et autres.

Type de données d'objet

Le type d'objet est un type spécial, étant le parent de tous les autres types dans le cadre d'application .NET. Il peut être déclaré avec mot-clef object et il peut prendre des valeurs de tout autre type. C'est un type de référence, c'est-à-dire un index (adresse) d'une zone mémoire entreposant la valeur actuel.

Les types de données nulles

Les types Nullable sont des enveloppeurs spécifiques autour des types de données de valeur (comme int, double et bool) permettant d'entreposer des données avec une valeur nulle. Il permet aux types de données d'offrir la possibilité d'utiliser l'absence de valeur (c'est-à-dire la valeur nulle) comme types de référence et d'accepter à la fois les valeurs normales et la valeur spéciale null. Ainsi, les types Nullable contiennent une valeur facultative. L'enveloppe d'un type de données spécifié comme Nullable peut être effectué de deux manières :


Nullable<int> variable1 = null;

int? variable2 = variable1;

Les deux déclarations sont équivalentes. Le moyen le plus simple d'effectuer cette opération est d'ajouter un point d'interrogation (?) Après le type, par exemple «int?». Le plus difficile est d'utiliser la syntaxe Nullable <...>. Les types Nullable sont des types de référence, c'est-à-dire qu'ils font référence à un objet dans la mémoire dynamique, contenant leur valeur actuelle. Ils peuvent ou non avoir une valeur et peuvent être utilisés comme types de données primitifs normaux, mais avec quelques spécificités.

Dernière mise à jour : Mardi, le 17 novembre 2020

Section courante

A propos

Section administrative du site