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

Dans ce didacticiel, nous allons découvrir les variables, comment créer des variables en C # et les différents types de données pris en charge par le langage de programmation C #.

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 age de type int(entier) est déclarée et elle 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, un âge variable de type intest déclaré et initialisé en 24même temps.

Puisque c'est une variable, nous pouvons également changer la valeur des variables. Par exemple,

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

Ici, la valeur de l'âge passe de 24 à 35 ans.

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 portées dans les chapitres suivants.

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

âge int; âge = 24;……… âge flottant;

Variables implicitement typées

Alternativement en C #, nous pouvons déclarer une variable sans connaître son type en utilisant le varmot clé. Ces variables sont appelées variables locales typées implicitement .

Les variables déclarées à l'aide du varmot-clé doivent être initialisées au moment de la déclaration.

 valeur var = 5;

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

valeur int; valeur = 5;

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

Règles de dénomination 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. Cela signifie que l'âge et l'âge se réfèrent à 2 variables différentes.
  4. Un nom de variable ne doit pas être un mot clé C #. Par exemple, if, for, usingne 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, le nom, l'âge, le sujet ont plus de sens que n, a et s.
  2. Utilisez la notation camelCase (commence par une lettre minuscule) pour nommer les variables locales. Par exemple, numberOfStudents, age, etc.
  3. Utilisez PascalCase ou CamelCase (commence par une lettre majuscule) pour nommer les variables membres publiques. Par exemple, Prénom, Prix, etc.
  4. Utilisez un tiret bas (_) suivi de la notation camelCase pour nommer les variables de membre privé. Par exemple, _bankBalance, _emailAddress, 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: les types de valeur et les types 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 des 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: trueoufalse
  • Valeur par défaut :false
  • Les variables booléennes sont généralement utilisées pour vérifier les conditions telles que les instructions if, les 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

  • Size: 8 bits
  • Range: -128 to 127.
  • Default value: 0

For example:

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

When we run the program, the output will be:

 23

Try assigning values out of range i.e. less than -128 or greater than 127 and see what happens.

2. short

  • Size: 16 bits
  • Range: -32,768 to 32,767
  • Default value: 0

For example:

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

When we run the program, the output will be:

 -1109

3. int

  • Size: 32 bits
  • Range: -231 to 231-1
  • Default value: 0

For example:

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

When we run the program, the output will be:

 51092

4. long

  • Size: 64 bits
  • Range: -263 to 263-1
  • Default value: 0L (L at the end represent the value is of long type)

For example:

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

When we run the program, the output will be:

 -7091821871

Unsigned Integral

These data types only hold values equal to or greater than 0. We generally use these data types to store values when we are sure, we won't have negative values.

1. byte

  • Size: 8 bits
  • Range: 0 to 255.
  • Default value: 0

For example:

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

When we run the program, the output will be:

 62

2. ushort

  • Size: 16 bits
  • Range: 0 to 65,535
  • Default value: 0

For example:

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

When we run the program, the output will be:

 42019

3. uint

  • Size: 32 bits
  • Range: 0 to 232-1
  • Default value: 0

For example:

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

When we run the program, the output will be:

 1151092

4. ulong

  • Size: 64 bits
  • Range: 0 to 264-1
  • Default value: 0

For example:

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

When we run the program, the output will be:

 17091821871

Floating Point

These data types hold floating point values i.e. numbers containing decimal values. For example, 12.36, -92.17, etc.

1. float

  • Single-precision floating point type
  • Size: 32 bits
  • Range: 1.5 × 10−45 to 3.4 × 1038
  • Default value: 0.0F (F at the end represent the value is of float type)

For example:

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

When we run the program, the output will be:

 43.27

2. double

  • Double-precision floating point type. What is the difference between single and double precision floating point?
  • Size: 64 bits
  • Range: 5.0 × 10−324 to 1.7 × 10308
  • Default value: 0.0D (D at the end represent the value is of double type)

For example:

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

When we run the program, the output will be:

 -11092.53

Character (char)

  • It represents a 16 bit unicode character.
  • Size: 16 bits
  • Default value: ''
  • Range: U+0000 ('u0000') to U+FFFF ('uffff')

For example: 

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

When we run the program, the output will be:

 B x

The unicode value of 'B' is 'u0042', hence printing ch1 will print 'B'.

Decimal

  • Decimal type has more precision and a smaller range as compared to floating point types (double and float). So it is appropriate for monetary calculations.
  • Size: 128 bits
  • Default value: 0.0M (M at the end represent the value is of decimal type)
  • Range: (-7.9 x 1028 to 7.9 x 1028) / (100 to 28)

For example: 

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

When we run the program, the output will be:

 53005.25

The suffix M or m must be added at the end otherwise the value will be treated as a double and an error will be generated.

C# Literals

Let's look at the following statement:

 int number = 41;

Here,

  • int is a data type
  • number is a variable and
  • 41 is a literal

Literals are fixed values that appear in the program. They do not require any computation. For example, 5, false, 'w' are literals that appear in a program directly without any computation.

Boolean Literals

  • true and false are the available boolean literals.
  • They are used to initialize boolean variables.

For example:

 bool isValid = true; bool isPresent = false;

Integer Literals

  • Integer literals are used to initialize variables of integer data types i.e. sbyte, short, int, long, byte, ushort, uint and ulong.
  • If an integer literal ends with L or l, it is of type long. For best practice use L (not l). 
     long value1 = 4200910L; long value2 = -10928190L;
  • If an integer literal starts with a 0x, it represents hexadecimal value. Number with no prefixes are treated as decimal value. Octal and binary representation are not allowed in C#. 
     int decimalValue = 25; int hexValue = 0x11c;// decimal value 284

Floating Point Literals

  • Floating point literals are used to initialize variables of float and double data types.
  • If a floating point literal ends with a suffix f or F, it is of type float. Similarly, if it ends with d or D, it is of type double. If neither of the suffix is present, it is of type double by default.
  • These literals contains e or E when expressed in scientific notation. 
     double number = 24.67;// double by default float value = -12.29F; double scientificNotation = 6.21e2;// equivalent to 6.21 x 102 i.e. 621

Character and String Literals

  • Character literals are used to initialize variables of char data types.
  • Character literals are enclosed in single quotes. For example, 'x', 'p', etc.
  • They can be represented as character, hexadecimal escape sequence, unicode representation or integral values casted to char. 
     char ch1 = 'R'; // character char ch2 = ' x0072'; // hexadecimal char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // casté à partir d'un entier
  • Les littéraux de chaîne sont la collection de littéraux de caractères.
  • Ils sont placés entre guillemets. Par exemple, "Bonjour", "Programmation facile", etc. 
    string firstName = "Richard"; string lastName = "Feynman";
  • C # prend également en charge les caractères de séquence d'échappement tels que:
    Personnage Sens
    \' Simple citation
    " Double citation
    \ Antislash
    Nouvelle ligne
    Retour chariot
    Onglet horizontal
    a Alerte
     Retour arrière

Articles intéressants...