Le qualificatif const peut être appliqué à la déclaration de n'importe quelle variable pour spécifier que sa valeur ne sera pas modifiée (ce qui dépend de l'endroit où les variables const sont stockées, nous pouvons modifier la valeur de la variable const en utilisant un pointeur). Le résultat est défini par l'implémentation si une tentative est faite pour modifier un const.
Utiliser le qualificatif const en C est une bonne pratique lorsque nous voulons nous assurer que certaines valeurs doivent rester constantes et ne doivent pas être modifiées accidentellement.
sqrt java mathématiques
En programmation C, le qualificatif const peut être utilisé dans différents contextes pour fournir différents comportements. Voici quelques différents cas d’utilisation du qualificatif const en C :
1. Variables constantes
const int var = 100;>
Dans ce cas, const est utilisé pour déclarer une variable était comme une constante avec une valeur initiale de 100. La valeur de cette variable ne peut plus être modifiée une fois initialisée. Voir l'exemple suivant :
C
// C program to demonstrate that constant variables can not> // be modified> #include> int> main()> {> >const> int> var = 100;> >// Compilation error: assignment of read-only variable> >// 'var'> >var = 200;> >return> 0;> }> |
>
>
Sortir
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Pointeur vers constante
const int* ptr;>
OU
int const *ptr;>
Nous pouvons modifier le pointeur pour qu'il pointe vers n'importe quelle autre variable entière, mais nous ne pouvons pas modifier la valeur de l'objet (entité) pointé à l'aide du pointeur ptr. Le pointeur est stocké dans la zone de lecture-écriture (pile dans le cas présent). L'objet pointé peut se trouver dans la zone de lecture seule ou de lecture-écriture. Voyons les exemples suivants.
Exemple 1:
C
comment renommer un répertoire sous Linux
// C program to demonstrate that the pointer to point to> // any other integer variable, but the value of the object> // (entity) pointed can not be changed> #include> int> main(>void>)> {> >int> i = 10;> >int> j = 20;> >/* ptr is pointer to constant */> >const> int>* ptr = &i;> >printf>(>'ptr: %d
'>, *ptr);> >/* error: object pointed cannot be modified> >using the pointer ptr */> >*ptr = 100;> >ptr = &j;>/* valid */> >printf>(>'ptr: %d
'>, *ptr);> >return> 0;> }> |
>
>
Sortir
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Exemple 2 : Programme où la variable i elle-même est constante.
C
// C program to demonstrate that the pointer to point to> // any other integer variable, but the value of the object> // (entity) pointed can not be changed> #include> int> main(>void>)> {> >/* i is stored in read only area*/> >int> const> i = 10;> >int> j = 20;> >/* pointer to integer constant. Here i> >is of type 'const int', and &i is of> >type 'const int *'. And p is of type> >'const int', types are matching no issue */> >int> const>* ptr = &i;> >printf>(>'ptr: %d
'>, *ptr);> >/* error */> >*ptr = 100;> >/* valid. We call it up qualification. In> >C/C++, the type of 'int *' is allowed to up> >qualify to the type 'const int *'. The type of> >&j is 'int *' and is implicitly up qualified by> >the compiler to 'const int *' */> >ptr = &j;> >printf>(>'ptr: %d
'>, *ptr);> >return> 0;> }> |
>
>
zone de liste HTML
Sortir
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Qualification vers le bas n'est pas autorisé en C++ et peut provoquer des avertissements en C. La qualification vers le bas fait référence à la situation dans laquelle un type qualifié est affecté à un type non qualifié.
Exemple 3 : Programme pour démontrer la qualification.
C
// C program to demonstrate the down qualification> #include> int> main(>void>)> {> >int> i = 10;> >int> const> j = 20;> >/* ptr is pointing an integer object */> >int>* ptr = &i;> >printf>(>'*ptr: %d
'>, *ptr);> >/* The below assignment is invalid in C++, results in> >error In C, the compiler *may* throw a warning, but> >casting is implicitly allowed */> >ptr = &j;> >/* In C++, it is called 'down qualification'. The type> >of expression &j is 'const int *' and the type of ptr> >is 'int *'. The assignment 'ptr = &j' causes to> >implicitly remove const-ness from the expression &j.> >C++ being more type restrictive, will not allow> >implicit down qualification. However, C++ allows> >implicit up qualification. The reason being, const> >qualified identifiers are bound to be placed in> >read-only memory (but not always). If C++ allows> >above kind of assignment (ptr = &j), we can use 'ptr'> >to modify value of j which is in read-only memory.> >The consequences are implementation dependent, the> >program may fail> >at runtime. So strict type checking helps clean code.> >*/> >printf>(>'*ptr: %d
'>, *ptr);> >return> 0;> }> |
>
>
concaténer les chaînes java
Sortir
main.c: In function ‘main’: main.c:16:9: warning: assignment discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers] 16 | ptr = &j; | ^ *ptr: 10 *ptr: 20>
3. Pointeur constant vers une variable
int* const ptr;>
La déclaration ci-dessus est un pointeur constant vers une variable entière, ce qui signifie que nous pouvons modifier la valeur de l'objet pointé par le pointeur, mais que nous ne pouvons pas modifier le pointeur pour qu'il pointe vers une autre variable.
Exemple
C
// C program to demonstrate that the value of object pointed> // by pointer can be changed but the pointer can not point> // to another variable> #include> int> main(>void>)> {> >int> i = 10;> >int> j = 20;> >/* constant pointer to integer */> >int>*>const> ptr = &i;> >printf>(>'ptr: %d
'>, *ptr);> >*ptr = 100;>/* valid */> >printf>(>'ptr: %d
'>, *ptr);> >ptr = &j;>/* error */> >return> 0;> }> |
>
>
Sortir
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Pointeur constant vers Constant
const int* const ptr;>
La déclaration ci-dessus est un pointeur constant vers une variable constante, ce qui signifie que nous ne pouvons pas modifier la valeur pointée par le pointeur et que nous ne pouvons pas non plus pointer le pointeur vers d'autres variables. Voyons avec un exemple.
C
// C program to demonstrate that value pointed by the> // pointer can not be changed as well as we cannot point the> // pointer to other variables> #include> int> main(>void>)> {> >int> i = 10;> >int> j = 20;> >/* constant pointer to constant integer */> >const> int>*>const> ptr = &i;> >printf>(>'ptr: %d
'>, *ptr);> >ptr = &j;>/* error */> >*ptr = 100;>/* error */> >return> 0;> }> |
>
java synchroniser
>
Sortir
./Solution.c: In function 'main': ./Solution.c:12:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^ ./Solution.c:13:10: error: assignment of read-only location '*ptr' *ptr = 100; /* error */ ^>
Avantages des qualificatifs const en C
Le qualificatif const en C présente les avantages suivants :
- Lisibilité améliorée du code : en marquant une variable comme const, vous indiquez aux autres programmeurs que sa valeur ne doit pas être modifiée, ce qui rend votre code plus facile à comprendre et à maintenir. Sécurité des types améliorée : en utilisant const, vous pouvez vous assurer que les valeurs ne sont pas accidentellement modifiées, réduisant ainsi le risque de bugs et d'erreurs dans votre code. Optimisation améliorée : les compilateurs peuvent optimiser les variables const plus efficacement, car ils savent que leurs valeurs ne changeront pas pendant l'exécution du programme. Cela peut aboutir à un code plus rapide et plus efficace. Meilleure utilisation de la mémoire : en déclarant les variables comme const, vous pouvez souvent éviter d'avoir à faire une copie de leurs valeurs, ce qui peut réduire l'utilisation de la mémoire et améliorer les performances. Compatibilité améliorée : en déclarant les variables comme const, vous pouvez rendre votre code plus compatible avec d'autres bibliothèques et API qui utilisent des variables const. Fiabilité améliorée : en utilisant const, vous pouvez rendre votre code plus fiable, car vous pouvez vous assurer que les valeurs ne sont pas modifiées de manière inattendue, réduisant ainsi le risque de bugs et d'erreurs dans votre code.
Résumé
| Taper | Déclaration | Changement de valeur du pointeur (*ptr = 100) | Changement de valeur de pointage (ptr = &a) |
|---|---|---|---|
| Pointeur vers une variable | int * ptr | Oui | Oui |
| Pointeur vers une constante | const int * ptr int const * ptr | Non | Oui |
| Pointeur constant vers une variable | int * const ptr | Oui | Non |
| Pointeur constant vers Constant | const int * const ptr | Non | Non |
Cet article est compilé par Narendra Kangralkar .