Maîtriser les constantes et littéraux en C# : types, règles et bonnes pratiques

Les constantes désignent des valeurs fixes que le programme ne peut pas modifier pendant son exécution. Ces valeurs fixes sont aussi appelées littéraux. Les constantes peuvent être de n'importe quel type de données de base : constante entière, constante à virgule flottante, constante caractère, ou littéral chaîne. Il existe aussi des constantes d'énumération.

Les constantes se comportent comme des variables ordinaires, sauf que leurs valeurs ne peuvent pas être modifiées après leur définition.

Littéraux entiers

Un littéral entier peut être une constante décimale ou hexadécimale. Un préfixe indique la base : 0x ou 0X pour l'hexadécimal, aucun préfixe pour le décimal.

Un littéral entier peut aussi avoir un suffixe combinant U et L pour unsigned et long. Le suffixe peut être majuscule ou minuscule, dans n'importe quel ordre.

Exemples

212        // Légal
215u       // Légal
0xFeeL     // Légal

Autres exemples

85         // décimal
0x4b       // hexadécimal
30         // int
30u        // unsigned int
30l        // long
30ul       // unsigned long

Littéraux à virgule flottante

Un littéral à virgule flottante comporte une partie entière, un point décimal, une partie fractionnaire et une partie exposant. On peut les représenter en forme décimale ou exponentielle.

Exemples

3.14159       // Légal
314159E-5F    // Légal
510E          // Illégal : exposant incomplet
210f          // Illégal : pas de point décimal ni d'exposant
.e55          // Illégal : partie entière ou fraction manquante

En forme décimale, il faut inclure le point décimal, l'exposant, ou les deux. En forme exponentielle, il faut inclure la partie entière, la partie fractionnaire, ou les deux. L'exposant signé est introduit par e ou E.

Constantes caractères

Les littéraux caractères sont encadrés par des apostrophes. Par exemple 'x' et peuvent être stockés dans une variable de type char. Un littéral caractère peut être :

• Un caractère simple (ex: 'x')
• Une séquence d'échappement (ex: '\t')
• Un caractère universel (ex: '\u02C0')

Certains caractères précédés d'une barre oblique inversée ont une signification spéciale :

Séquence d'échappement	Signification
\\	Caractère \
\'	Caractère ' (apostrophe)
\"	Caractère " (guillemet)
\?	Caractère ?
\a	Alerte (beep)
\b	Retour arrière (backspace)
\f	Saut de page (form feed)
\n	Nouvelle ligne
\r	Retour chariot
\t	Tabulation horizontale
\v	Tabulation verticale
\xhh...	Nombre hexadécimal d'un ou plusieurs chiffres

Exemple avec séquences d'échappement

using System;

namespace CaractereEchappement
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello\tWorld\n\n");
            Console.ReadLine();
        }
    }
}

Résultat :

Hello World

Littéraux chaînes

Les littéraux chaînes sont encadrés par des guillemets doubles "" ou avec @"". Une chaîne contient des caractères similaires aux littéraux caractères : caractères simples, séquences d'échappement et caractères universels.

On peut couper une longue ligne en plusieurs lignes en utilisant des littéraux chaînes séparés par des espaces.

Exemples (toutes identiques)

"hello, dear"
"hello, \ dear"
"hello, " "d" "ear"
@"hello dear"

Définition des constantes

Les constantes sont définies avec le mot-clé const. Syntaxe :

const <type_données> <nom_constante> = valeur;

Exemple complet

using System;

namespace DeclarationConstantes
{
    class Program
    {
        static void Main(string[] args)
        {
            const double pi = 3.14159; // déclaration constante
            double r;
            
            Console.WriteLine("Entrez le rayon : ");
            r = Convert.ToDouble(Console.ReadLine());
            
            double aireCercle = pi * r * r;
            Console.WriteLine("Rayon : {0}, Aire : {1}", r, aireCercle);
            Console.ReadLine();
        }
    }
}

Résultat (pour rayon = 3) :

Entrez le rayon : 3
Rayon : 3, Aire : 28.27431