Programmation en C# – Les constantes

Les constantes se réfèrent à des valeurs fixes que le programme n’en peut pas modifier pendant son exécution. Ces valeurs fixes sont également appelées littéraux. Les constantes peuvent être de l’un des types de données de base comme int, char, float, etc. Il existe aussi des constantes de type enum.

Les constantes sont traitées comme des variables régulières, sauf que leurs valeurs ne peuvent pas être modifiées après leur définition.
 
 

Littéral entier

Un littéral entier peut être un décimale ou une constante hexadécimale. Un préfixe spécifie la base: 0x ou 0X pour l’hexadécimal, et il n’y a pas de préfixe id pour décimal.

Un entier littéral peut également avoir un suffixe qui est une combinaison de U et L, pour non signé et long, respectivement. Le suffixe peut être majuscule ou minuscule et peut être dans n’importe quel ordre.

Voici quelques exemples de littéraux entiers:

356         /* Légal */
356u        /* Légal*/
0xSolde     /* Légal */

Voici d’autres exemples de différents types de littéraux entiers:

79     /* décimale */
0x5b   /* hexadécimal */
80     /* int */
50u    /* int non signé */
10l    /* long */
40ul   /* long non signé */

 

Littéral à virgule flottante

Un littéral à virgule flottante a une partie entière, un point décimal, une partie fractionnée et une partie exposante. Vous pouvez représenter des littéraux en virgule flottante soit sous forme décimale, soit sous forme exponentielle.

Voici quelques exemples de littéraux à virgule flottante:

9.14179       /* Légal */
98159E-9F    /* Légal */
417E        /* Illégal: exposant incomplet */
818f       /* Illégal: pas de décimale ou d'exposant */
.e45      /* Illégal: nombre entier ou partie fraction manquant */

Tout en représentant une forme décimale, vous devez inclure le point décimal, l’exposant ou les deux; Et tout en représentant l’utilisation d’une forme exponentielle, vous devez inclure la partie entière, la partie fractionnaire ou les deux. L’exposant signé est présenté par e ou E.

 

 

Caractères constantes

Les littéraux de caractères sont entre guillemets simples. Par exemple, ‘x’ et peuvent être stockés dans une variable simple de type char. Un caractère littéral peut être un caractère simple (tel que ‘x’), une séquence d’échappement (par exemple ‘ t’) ou un caractère universel (tel que ‘ u02C0’).

Il existe certains caractères en C# lorsqu’ils sont précédés d’une barre oblique inverse. Ils ont une signification particulière et ils sont utilisés pour représenter comme newline ( n) ou tabulation( t). Voici une liste de certains de ces codes de séquence d’échappement:

Séquence d’échappement	Sens
\	caractère
‘	‘ caractère
?	? caractère
a	alert
b	backspace
f	feed
n	Nouvelle ligne
r	Retour chariot
t	Tab horizontal
v	Tab vertical
xhh . . .	Numéro hexadécimal d’un ou plusieurs chiffres

Voici l’exemple pour montrer quelques caractères de séquence d’échappement:

using System;
namespace SéquenceEchappement
{
   class Test
   {
      static void Main(string[] args)
      {
         Console.WriteLine("Hello\tWorld\n\n\n");
         Console.ReadLine();
      }
   }
} 

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Hello   World

 

 

Les chaînes de caractères – String

Les chaînes de caractères sont placés entre guillemets " " ou @" ". Une chaînes de caractère contient des caractères similaires aux caractères littéraires: caractères simples, séquences d’échappement et caractères universels.

Voici quelques exemples.

"Bonjour, Mr"
"Bonjour, 
Mr"
"Bonjour , " "M" "r"
@"Bonjour, Mr"

 

Définition des constantes

Les constantes sont définies à l’aide du mot-clé const. La syntaxe pour définir une constante est:

const <type_de_données> <nom_de_la_constante> = valeur;

Le programme suivant montre la définition et l’utilisation d’une constante:

using System;
namespace DeclarationDesConstants
{
    class Test
    {
        static void Main(string[] args)
        {
            // déclaration d'une constante
            const double pi = 3.14159;   
            double d;
            Console.WriteLine("Entrer le rayon: ");
            d = Convert.ToDouble(Console.ReadLine());
            double surfaceCercle = pi * d * d;
            Console.WriteLine("Rayons: {0}, Surface: {1}", d, surfaceCercle);
            Console.ReadLine();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Entrer le rayon: 3
Rayon: 3, Surface: 28.27431