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’échappementSens
\caractère
‘ caractère
?? caractère
aalert
bbackspace
ffeed
nNouvelle ligne
rRetour chariot
tTab horizontal
vTab 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

 

Partagez cet article

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *