Constantes locales

Constantes locales (Local Constants)

Les constantes locales ressemblent beaucoup aux variables locales, à une différence près : une fois initialisée, la valeur d’une constante ne peut pas être modifiée.

Tout comme les variables locales, les constantes doivent être déclarées à l’intérieur d’un bloc de code.

Les constantes disposent de deux caractéristiques principales :

1. Elles doivent recevoir une valeur à la déclaration ;
2. Aucune modification de valeur n’est autorisée après la déclaration.

Syntaxe de base des constantes

const Type NomConstante = ValeurInitiale;

// const : mot-clé, à placer directement devant le type
// = ValeurInitiale : obligatoire, ne peut pas être omis
Langage du code : JavaScript (javascript)

Présentation des règles syntaxiques

Par rapport à une déclaration classique de champ ou de variable, deux différences apparaissent :

1. Ajouter le mot-clé const avant le type de données ;
2. Il faut fournir une valeur initiale, et cette valeur doit être déterminable à la compilation :
   • Généralement des littéraux de type primitif ou des expressions composées de types primitifs ;
   • L’affectation de null est autorisée ;
   • Il est interdit d’affecter une référence d’instance d’objet (les références d’objet ne sont connues qu’à l’exécution, ce qui ne respecte pas les contraintes des constantes de compilation).

class Program
{
    static void Main()
    {
        int a = 10; // ceci est une variable

        const int b = 20; // ceci est une constante, proche d’une variable
                          // le mot-clé const indique qu’il s’agit d’une constante

        a = 100; // une variable peut être modifiée
        a = 200; // on peut la changer autant de fois que l’on veut

        // Erreur
        b = 300; // une constante ne peut pas être modifiée, le compilateur signale une erreur

        // Les constantes améliorent la lisibilité et la maintenabilité du code

        
        int c; // déclaration
        c = 12; // pour une variable, on peut séparer déclaration et affectation

        // Une constante n’autorise pas la séparation entre déclaration et initialisation
        // Erreur
        const double d; // déclaration seule
        d = 3.14; // valide pour une variable, invalide pour une constante
    }
}Langage du code : C# (cs)

Ces deux erreurs ont des origines distinctes : la première tente de modifier la valeur d’une constante, la seconde sépare la déclaration de l’initialisation. Déclaration et initialisation d’une constante doivent avoir lieu simultanément.

Peut-on utiliser un objet de classe comme constante ?

L’expression affectée à la constante phone doit être une constante de compilation.

new Phone() alloue de la mémoire tas et crée un objet pendant l’exécution du programme ; c’est une valeur d’exécution.

En C#, il est interdit d’affecter une référence d’objet d’exécution à une constante locale const, ce qui provoque l’erreur de compilation CS0133.

class Program
{
    static void Main()
    {
        const Phone phone = new Phone();
    }
}

class Phone
{

}Langage du code : C# (cs)

Compléments sur le mot-clé

const n’est pas un modificateur. Il fait partie intégrante de la syntaxe de déclaration et doit être écrit directement devant le type de données.

Les mots-clés comme private, public et protected sont les véritables modificateurs.

Règles de portée et exemple

Les règles de portée des constantes locales sont identiques à celles des variables locales. Si déclarée dans une méthode ou un bloc de code, une constante cesse d’exister et sort de portée à la fin du bloc.

void ShowArea()
{
    const double PI = 3.1416; // déclarer la constante locale PI
    for (int radius = 1; radius <= 5; radius++) // afficher l’aire des cercles de rayon 1 à 5
    {
        double area = radius * radius * PI; // lire la valeur de la constante PI
        Console.WriteLine($"Rayon: {radius}, Aire: {area}");
    }
}
Langage du code : C# (cs)

La constante PI n’est accessible qu’à l’intérieur de la méthode ShowArea et est détruite à la fin de l’exécution de cette méthode.

class Program
{
    static void Main()
    {
        ShowArea();
    }

    static void ShowArea()
    {
        const double PI = 3.1416; 
        for (int radius = 1; radius <= 5; radius++) 
        {
            double area = radius * radius * PI;
            Console.WriteLine($"Radius: {radius}, Area: {area}");
        }
    }

}
Langage du code : C# (cs)

Constantes locales