Constante C

Types de constantes C

En programmation C, les constantes peuvent être classées dans les catégories suivantes :

• Constantes entières
• Constantes à virgule flottante
• Constantes de caractères

Constantes entières en C

Les constantes entières sont des nombres entiers qui peuvent être positifs ou négatifs. Elles sont exprimées dans la base 10 (décimale), la base 8 (octale) ou la base 16 (hexadécimale). Quelques règles s'appliquent aux constantes entières :

• Aucune virgule ni aucun blanc n'est autorisé à l'intérieur de la constante.
• Les constantes décimales ne doivent pas être préfixées par des zéros.
• Les constantes octales sont préfixées par un "0" (zéro).
• Les constantes hexadécimales sont préfixées par '0x' ou '0X'.

Constantes à virgule flottante en C

Les constantes à virgule flottante représentent des nombres réels et peuvent être représentées sous deux formes : la forme fractionnaire et la forme exposant. La forme fractionnaire comprend un point décimal, tandis que la forme exposant comprend un "e" ou "E", suivi d'un exposant entier. Quelques règles s'appliquent aux constantes à virgule flottante :

• Au moins un chiffre doit être présent avant et après la virgule dans la forme fractionnaire.
• Un exposant sous forme d'exposant doit être un nombre entier.
• L'utilisation du suffixe 'f' ou 'F' désigne une constante à virgule flottante en simple précision, tandis que 'l' ou 'L' désigne un double long. Sans ces suffixes, la constante est considérée comme un double.

Constantes de caractères en C

Les constantes de caractères représentent des caractères uniques, placés entre guillemets simples. Il peut s'agir de lettres, de chiffres ou de caractères spéciaux, ainsi que de séquences d'échappement. Chaque constante de caractère est de type entier, correspondant à la valeur entière du caractère dans la table ASCII.

Mise en œuvre des constantes C dans la programmation

Dans la programmation en C, les constantes sont définies à l'aide du mot-clé "const", suivi du type de données, puis du nom de la constante, auquel est attribuée une valeur spécifique et immuable. La syntaxe pour définir une constante C est la suivante :

const data_type nom_constante = valeur ;

Il est conseillé d'utiliser des lettres majuscules pour les noms de constantes afin de les différencier des noms de variables. En outre, les constantes peuvent être définies en tant que directives du préprocesseur (macros) à l'aide de la directive '#define', comme suit :

#define CONSTANT_NAME valeur

Cette méthode n'implique pas l'utilisation du mot-clé "const" ou la déclaration d'un type de données pour la constante. Au lieu de cela, le préprocesseur remplace toutes les occurrences du nom de la constante par leur valeur correspondante au cours du processus de compilation.

const int SIZE = 10 ; // en utilisant le mot clé 'const' const float PI = 3.14159F ; // en utilisant le mot clé 'const' #define LENGTH 50 // en utilisant la directive '#define' #define AREA (LENGTH * WIDTH) // macro avec une expression  

Utilisation des valeurs des constantes C

Les constantes peuvent être utilisées dans divers éléments de programmation, notamment les expressions, les tableaux, les paramètres de fonction et les structures. L'utilisation de constantes dans les constructions de programmation garantit un comportement cohérent, améliore la lisibilité du code et maintient l'intégrité des données en les protégeant contre les modifications involontaires.

Les expressions constantes en C

Une expression constante est évaluée à une valeur constante entièrement pendant le processus de compilation. Les expressions constantes peuvent inclure des constantes entières, flottantes ou de caractères, ainsi que des constantes d'énumération et certains appels de fonction. Elles sont utilisées dans les situations suivantes :

• Définir la taille des tableaux statiques ou globaux
• Déclarer les étiquettes de casse dans les instructions de commutation
• Spécifier des valeurs pour les énumérateurs
• Définition d'arguments de fonction constants

const int ARR_SIZE = 50 ; // taille du tableau int values[ARR_SIZE] ; // tableau statique switch (grade) { case 'A' :                        // case label // code break ; } 

Constantes d'énumération en C

Les constantes d'énumération sont des noms symboliques attribués à un ensemble de valeurs constantes entières. Les énumérations sont des types de données définis par l'utilisateur, utilisés pour représenter une collection de valeurs apparentées d'une manière plus lisible et plus explicite. Elles sont déclarées à l'aide du mot-clé "enum", suivi du nom de l'énumération et de la liste des énumérateurs entre accolades. Chaque énumérateur de la liste se voit attribuer une valeur entière unique, commençant par 0 par défaut et s'incrémentant de 1 pour chaque énumérateur suivant. Cependant, tu peux spécifier explicitement des valeurs entières pour les énumérateurs si nécessaire.

enum nom_de_l'énumération { énumérateur1 [= valeur1], énumérateur2 [= valeur2], ... } ;

Les constantes d'énumération peuvent être utilisées dans diverses constructions, telles que les instructions de commutation, les expressions conditionnelles et les instructions de bouclage. En outre, elles peuvent être utilisées comme arguments pour les fonctions qui attendent des valeurs entières.

enum Days { SUNDAY, // 0 MONDAY, // 1 TUESDAY, // 2 WEDNESDAY, // 3 THURSDAY, // 4 FRIDAY, // 5 SATURDAY // 6 } ; int main() { enum Days today ; today = WEDNESDAY ; // ... } 

Exemples et applications des constantes C

L'utilisation de constantes dans les programmes C permet d'éviter les erreurs et d'améliorer la maintenabilité du code. Dans l'exemple suivant, nous allons utiliser des constantes pour calculer la surface d'un cercle :

#include const float PI = 3.14159 ; int main() { float radius, area ; printf("Enter radius : ") ; scanf("%f", &radius) ; area = PI * radius * radius ; printf("Area of the circle is : %.2f\n", area) ; return 0 ; }

Dans cet exemple, nous définissons la constante 'PI' comme une valeur à virgule flottante représentant la constante mathématique π. La valeur de PI reste constante tout au long du programme et ne peut pas être modifiée. En utilisant la constante, nous éliminons le risque de modifier par inadvertance la valeur de PI, ce qui entraînerait des résultats incorrects ou un comportement incohérent. Le programme calcule ensuite l'aire du cercle en utilisant la constante PI et le rayon fourni par l'utilisateur.

Tableau constant en C

Un tableau constant en C est un tableau dont les éléments ne peuvent pas être modifiés. Tu peux créer un tableau constant en le déclarant avec le mot-clé "const", ce qui signifie que son contenu doit rester constant tout au long du programme. Voici un exemple de déclaration d'un tableau constant en C :

#include const char DAYS_OF_WEEK[7][10] = { " Sunday", " Monday", " Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" } ; int main() { for (int i = 0 ; i < 7 ; i++) { printf("%s\n", DAYS_OF_WEEK[i]) ; } return 0 ; }

Dans cet exemple, nous définissons un tableau de caractères constant à deux dimensions 'DAYS_OF_WEEK', qui contient les noms des jours de la semaine. Le tableau est marqué comme constant à l'aide du mot-clé 'const', ce qui indique que ses éléments ne peuvent pas être modifiés tout au long de l'exécution du programme.

Modifier un tableau constant en C (possible ou non ?)

Toute tentative de modification d'un tableau constant en C entraînera des erreurs de compilation, car les constantes sont censées rester immuables tout au long de l'exécution du programme. Si tu tentes de modifier un tableau de constantes, le compilateur lèvera une erreur, t'avertissant de la violation de la constance. L'exemple suivant montre ce qui se passe lorsque tu tentes de modifier un tableau de constantes :

#include const int NUMBERS[5] = { 1, 2, 3, 4, 5 } ; int main() { // Tentative de modification d'un tableau constant NUMBERS[0] = 10 ; // Cette ligne provoquera une erreur de compilation return 0 ; }

Lorsqu'il tente de compiler le code ci-dessus, le compilateur génère un message d'erreur en raison de la tentative de modification du tableau de constantes 'NUMBERS'. Le message d'erreur indique qu'il n'est pas possible d'attribuer une nouvelle valeur à un élément d'un tableau constant.

Pointeur constant en C

Un pointeur constant en C est un pointeur qui ne peut pas changer l'adresse vers laquelle il pointe une fois qu'il a été assigné. Tu peux créer un pointeur constant en utilisant le mot-clé "const" dans la déclaration du pointeur et en le plaçant après le type de données. La syntaxe pour déclarer un pointeur constant est la suivante :

type_de_données *const nom_du_pointeur = adresse_mémoire ;

La déclaration d'un pointeur constant garantit que l'adresse vers laquelle il pointe reste immuable tout au long de l'exécution du programme. Voici un exemple de déclaration et d'utilisation d'un pointeur constant en C :

#include int main() { int num = 42 ; int const *ptr = # printf("Value at address %p is %d\n", ptr, *ptr) ; // La ligne suivante entraînerait une erreur de compilation // ptr = &another_variable ; return 0 ; }

Utiliser un pointeur constant en C

Une fois déclaré et affecté à une adresse mémoire, un pointeur constant ne peut pas être modifié pour pointer sur une adresse différente. Cependant, la valeur à l'adresse pointée peut toujours être modifiée. C'est utile lorsque tu veux t'assurer que le pointeur pointe toujours vers l'adresse prévue et éviter de l'affecter par inadvertance à un emplacement mémoire différent. Voici un exemple d'utilisation d'un pointeur constant en C :

#include int main() { int num = 42 ; int another_variable = 99 ; int *const ptr = # printf("Value at address %p is %d\n", ptr, *ptr) ; // La ligne suivante n'entraînera PAS d'erreur de compilation num = 100 ; printf("Updated value at address %p is %d\n", ptr, *ptr) ; // Cependant, cette ligne entraînerait une erreur de compilation : // ptr = &another_variable ; return 0 ; }.

Dans cet exemple, nous avons un pointeur 'ptr', qui pointe vers l'adresse de la variable 'num'. Après avoir déclaré le pointeur comme constant, nous pouvons toujours mettre à jour la valeur de 'num', mais nous ne pouvons pas changer l'adresse vers laquelle 'ptr' pointe. Si nous essayons de mettre à jour l'adresse, le compilateur génère un message d'erreur.