Variables C # et types de données (primitifs)

Une variable est un nom symbolique donné à un emplacement mémoire. Les variables sont utilisées pour stocker des données dans un programme informatique.


Comment déclarer des variables en C #?

Voici un exemple pour déclarer une variable en C #.

âge int;

Dans cet exemple, une variableâgede type int (integer) est déclaré et ne peut stocker que des valeurs entières.

Nous pouvons attribuer une valeur à la variable plus tard dans notre programme comme ceci:

âge int;
... ... ...
âge = 24;

Cependant, la variable peut également être initialisée à une certaine valeur lors de la déclaration. Par exemple,

âge int = 24;

Ici, une variableâgede type int est déclaré et initialisé à 24 en même temps.

Comme il s’agit d’une variable, nous pouvons également modifier la valeur des variables. Par exemple,

âge int = 24;
âge = 35 ans;

Ici, la valeur deâgepasse de 24 à 35.


Les variables en C # doivent être déclarées avant de pouvoir être utilisées. Cela signifie que le nom et le type de variable doivent être connus avant de pouvoir leur attribuer une valeur. C’est pourquoi C # est appelé un langage à typage statique.

Une fois déclaré, le type de données d’une variable ne peut pas être modifié dans une portée. Une portée peut être considérée comme un bloc de code où la variable est visible ou disponible à l’utilisation. Si vous ne comprenez pas la déclaration précédente, ne vous inquiétez pas, nous en apprendrons davantage sur les champs d’application dans les chapitres suivants.

Pour l’instant, rappelez-vous, nous ne pouvons pas faire ce qui suit en C #:

âge int;
âge = 24;
... ... ...
l'âge du flotteur;

Variables implicitement typées

Alternativement en C #, on peut déclarer une variable sans connaître son type en utilisant var mot-clé. Ces variables sont appeléesvariables locales typées implicitement.

Variables déclarées avec var Le mot clé doit être initialisé au moment de la déclaration.

valeur var = 5;

Le compilateur détermine le type de variable à partir de la valeur attribuée à la variable. Dans l’exemple ci-dessus,valeurest de type int . Cela équivaut à:

valeur int;
valeur = 5;

Vous pouvez en savoir plus sur les variables locales typées implicitement.


Règles de nommage des variables en C #

Il y a certaines règles que nous devons suivre pour nommer une variable. Les règles pour nommer une variable en C # sont:

  1. Le nom de la variable ne peut contenir que des lettres (majuscules et minuscules), des traits de soulignement (_) et des chiffres.
  2. Le nom de la variable doit commencer par une lettre, un trait de soulignement ou un symbole @. Par exemple,
    Règles de dénomination des variables en C #
    Noms de variables Remarques
    Nom Valide
    sujet101 Valide
    _âge Valide (meilleure pratique pour nommer les variables de membre privé)
    @Pause Valide (utilisé si nom est un mot-clé réservé)
    101subjet Non valide (commence par un chiffre)
    votre nom Valide
    votre nom Non valide (contient des espaces)
  3. C # est sensible à la casse. Ça veut direâgeetÂgefait référence à 2 variables différentes.
  4. Un nom de variable ne doit pas être un mot clé C #. Par exemple, if ,  for ,  using ne peut pas être un nom de variable. Nous discuterons plus en détail des mots-clés C # dans le prochain tutoriel.

Meilleures pratiques pour nommer une variable

  1. Choisissez un nom de variable qui a du sens. Par exemple,Nom, âge, matièrea plus de sens quen, uneets.
  2. Utilisationaffaire de chameaunotation (commence par une lettre minuscule) pour nommer les variables locales. Par exemple,nombre d’étudiants, âge, etc.
  3. UtilisationPascalCaseouAffaire de chameau(commence par une lettre majuscule) pour nommer les variables membres publiques. Par exemple,Prénom, Prix, etc.
  4. Utilisez un tiret bas (_) suivi deaffaire de chameaunotation pour nommer les variables de membre privé. Par exemple,_solde bancaire, _adresse e-mail, etc.

Vous pouvez en savoir plus sur les conventions de dénomination en C # ici.

Ne vous inquiétez pas des variables membres publiques et privées. Nous en apprendrons davantage sur eux dans les chapitres suivants.


Types de données primitifs C #

Les variables en C # sont généralement classées en deux types:Types de valeuretTypes de référence. Dans ce didacticiel, nous discuterons des types de données primitifs (simples) qui sont une sous-classe des types Value.

Les types de référence seront traités dans les didacticiels ultérieurs. Cependant, si vous souhaitez en savoir plus sur les types de variables, visitez Types et variables C # (documentation officielle C #).

Booléen (booléen)

  • Le type de données booléen a deux valeurs possibles: true ou false 
  • Valeur par défaut:  false 
  • Les variables booléennes sont généralement utilisées pour vérifier des conditions telles que dansdéclarations if, boucles, etc.

Par exemple:

 using System;
namespace DataType
{
    class BooleanExample
    {
        public static void Main(string[] args)
        {
            bool isValid = true;
            Console.WriteLine(isValid);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

Vrai

Signé intégral

Ces types de données contiennent des valeurs entières (positives et négatives). Sur le nombre total de bits disponibles, un bit est utilisé pour le signe.

1. sbyte

  • Taille: 8 bits
  • Intervalle: -128 à 127.
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class SByteExample
    {
        public static void Main(string[] args)
        {
            sbyte level = 23;
            Console.WriteLine(level);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

23

Essayez d’attribuer des valeurs hors plage, c’est-à-dire inférieures à -128 ou supérieures à 127 et voyez ce qui se passe.


2. court

  • Taille: 16 bits
  • Intervalle: -32 768 à 32 767
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class ShortExample
    {
        public static void Main(string[] args)
        {
            short value = -1109;
            Console.WriteLine(value);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

-1109

3. int

  • Taille: 32 bits
  • Intervalle: -231 à 231-1
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class IntExample
    {
        public static void Main(string[] args)
        {
            int score = 51092;
            Console.WriteLine(score);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

51092

4. long

  • Taille: 64 bits
  • Intervalle: -263 à 263-1
  • Valeur par défaut:  0L [L à la fin représente que la valeur est de type long]

Par exemple:

 using System;
namespace DataType
{
    class LongExample
    {
        public static void Main(string[] args)
        {
            long range = -7091821871L;
            Console.WriteLine(range);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

-7091821871

Intégrale non signée

Ces types de données ne contiennent que des valeurs égales ou supérieures à 0. Nous utilisons généralement ces types de données pour stocker des valeurs lorsque nous sommes sûrs que nous n’aurons pas de valeurs négatives.

1. octet

  • Taille: 8 bits
  • Intervalle: 0 à 255.
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class ByteExample
    {
        public static void Main(string[] args)
        {
            byte age = 62;
            Console.WriteLine(level);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

62

2. ushort

  • Taille: 16 bits
  • Intervalle: 0 à 65 535
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class UShortExample
    {
        public static void Main(string[] args)
        {
            ushort value = 42019;
            Console.WriteLine(value);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

42019

3. uint

  • Taille: 32 bits
  • Intervalle: 0 à 232-1
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class UIntExample
    {
        public static void Main(string[] args)
        {
            uint totalScore = 1151092;
            Console.WriteLine(totalScore);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

1151092

4. ulong

  • Taille: 64 bits
  • Intervalle: 0 à 264-1
  • Valeur par défaut: 0

Par exemple:

 using System;
namespace DataType
{
    class ULongExample
    {
        public static void Main(string[] args)
        {
            ulong range = 17091821871L;
            Console.WriteLine(range);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

17091821871

Point flottant

Ces types de données contiennent des valeurs à virgule flottante, c’est-à-dire des nombres contenant des valeurs décimales. Par exemple, 12,36, -92,17, etc.

1. flotter

  • Type à virgule flottante simple précision
  • Taille: 32 bits
  • Intervalle: 1,5 × 10−45 à 3,4 × 1038
  • Valeur par défaut: 0.0F [F à la fin représente que la valeur est de type float]

Par exemple:

 using System;
namespace DataType
{
    class FloatExample
    {
        public static void Main(string[] args)
        {
            float number = 43.27F;
            Console.WriteLine(number);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

43.27

2. double

  • Type à virgule flottante double précision. Quelle est la différence entre la virgule flottante simple et double précision?
  • Taille: 64 bits
  • Intervalle: 5,0 × 10−324 à 1,7 × 10308
  • Valeur par défaut: 0.0D [D à la fin représente que la valeur est de type double]

Par exemple:

 using System;
namespace DataType
{
    class DoubleExample
    {
        public static void Main(string[] args)
        {
            double value = -11092.53D;
            Console.WriteLine(value);
        }
    }
} 

Lorsque nous exécutons le programme, la sortie sera:

-11092.53

Caractère (char)

  • Il représente un caractère Unicode 16 bits.
  • Taille: 16 bits
  • Valeur par défaut: ‘\0’
  • Intervalle: U + 0000 (‘\ u0000’) à U + FFFF (‘\ uffff’)

Par exemple:   

 using System;
namespace DataType
{
    class CharExample
    {
        public static void Main(string[] args)
        {
            char ch1 ='\u0042';
            char ch2 = 'x';
            Console.WriteLine(ch1);
            Console.WriteLine(ch2);
        }
    }
}
 

Lorsque nous exécutons le programme, la sortie sera:

B
X

La valeur unicode de 'B' est '\u0042' , d’où l’impressionch1va imprimer 'B' .


Décimal

  • Le type décimal a plus de précision et une plage plus petite que les types à virgule flottante (double et float). Il convient donc aux calculs monétaires.
  • Taille: 128 bits
  • Valeur par défaut: 0.0M [M à la fin représente que la valeur est de type décimal]
  • Intervalle: (-7,9 x 1028 à 7,9 x 1028) / (100 à 28)

Par exemple:   

 using System;
namespace DataType
{
    class DecimalExample
    {
        public static void Main(string[] args)
        {
         decimal bankBalance = 53005.25M;
            Console.WriteLine(bankBalance);
        }
    }
}
 

Lorsque nous exécutons le programme, la sortie sera:

53005.25

Le suffixe M ou m doit être ajouté à la fin sinon la valeur sera traitée comme un double et une erreur sera générée.


Littéraux C #

Regardons la déclaration suivante:

nombre int = 41;

Ici,

  •  int est un type de données
  • nombreest une variable et
  •  41 est un littéral

Les littéraux sont des valeurs fixes qui apparaissent dans le programme. Ils ne nécessitent aucun calcul. Par exemple, 5 ,  false ,  'w' sont des littéraux qui apparaissent directement dans un programme sans aucun calcul.


Littéraux booléens

  • true et false sont les littéraux booléens disponibles.
  • Ils sont utilisés pour initialiser des variables booléennes.

Par exemple:

booléen isValid = true;
booléen isPresent = false;

Littéraux entiers

  • Les littéraux entiers sont utilisés pour initialiser les variables de types de données entiers, c’est-à-dire sbyte ,  short ,  int ,  long ,  byte ,  ushort ,  uint et ulong .
  • Si un littéral entier se termine par L ou l , il est de type long. Pour une utilisation optimale L (ne pas l ).
    valeur longue1 = 4200910L;
    valeur longue2 = -10928190L;
  • Si un littéral entier commence par un 0x , il représente une valeur hexadécimale. Les nombres sans préfixe sont traités comme des valeurs décimales. Les représentations octales et binaires ne sont pas autorisées en C #.
    int decimalValue = 25;
    int hexValue = 0x11c; // valeur décimale 284

Littéraux à virgule flottante

  • Les littéraux à virgule flottante sont utilisés pour initialiser les variables des types de données float et double.
  • Si un littéral à virgule flottante se termine par un suffixe f ou F , il est de type float. De même, s’il se termine par d ou D , il est de type double. Si aucun des suffixes n’est présent, il est de type double pardéfaut.
  • Ces littéraux contiennent e ou E lorsqu’ils sont exprimés en notation scientifique.
    nombre double = 24,67; // double par défaut
    valeur flottante = -12,29F;
    double ScientificNotation = 6,21e2; // équivalent à 6,21 x 102 soit 621

Littéraux de caractères et de chaînes