El qualificatiu const es pot aplicar a la declaració de qualsevol variable per especificar que el seu valor no es canviarà (que depèn d'on s'emmagatzemen les variables const, podem canviar el valor de la variable const utilitzant un punter). El resultat es defineix per la implementació si s'intenta canviar una const.
L'ús del qualificador const en C és una bona pràctica quan volem assegurar-nos que alguns valors han de romandre constants i no s'han de modificar accidentalment.
botó al centre css
A la programació en C, el qualificador const es pot utilitzar en diferents contextos per proporcionar diversos comportaments. Aquests són alguns casos d'ús diferents del qualificador const en C:
1. Variables constants
const int var = 100;>
En aquest cas, const s'utilitza per declarar una variable era com a constant amb un valor inicial de 100. El valor d'aquesta variable no es pot modificar un cop s'ha inicialitzat. Vegeu l'exemple següent:
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;> }> |
>
>
Sortida
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Punter a la constant
const int* ptr;>
O
int const *ptr;>
Podem canviar el punter perquè apunti a qualsevol altra variable entera, però no podem canviar el valor de l'objecte (entitat) apuntat amb el punter ptr. El punter s'emmagatzema a l'àrea de lectura-escriptura (pila en el cas actual). L'objecte apuntat pot estar a l'àrea de només lectura o lectura-escriptura. Vegem els següents exemples.
Exemple 1:
C
tipus de xarxa
// 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;> }> |
>
>
Sortida
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Exemple 2: programa on la mateixa variable i és constant.
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;> }> |
>
>
Sortida
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Qualificació baixa no està permès a C++ i pot provocar advertències en C. La qualificació baixa fa referència a la situació en què s'assigna un tipus qualificat a un tipus no qualificat.
Exemple 3: programa per mostrar la qualificació.
C
connectar java amb mysql
// 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;> }> |
>
>
comparar amb la cadena
Sortida
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. Apuntador constant a la variable
int* const ptr;>
La declaració anterior és un punter constant a una variable entera, el que significa que podem canviar el valor de l'objecte apuntat pel punter, però no podem canviar el punter perquè apunti a una altra 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;> }> |
>
>
Sortida
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Constant Apuntador a constant
const int* const ptr;>
La declaració anterior és un punter constant a una variable constant, la qual cosa significa que no podem canviar el valor assenyalat pel punter així com tampoc podem apuntar el punter a altres variables. Vegem-ho amb 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;> }> |
tutorial javafx
>
>
Sortida
./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 */ ^>
Avantatges dels qualificadors const en C
El qualificador const en C té els avantatges següents:
- Llegibilitat del codi millorada: en marcar una variable com a const, indiqueu a altres programadors que no s'hauria de canviar el seu valor, fent que el vostre codi sigui més fàcil d'entendre i mantenir. Seguretat de tipus millorada: en utilitzar const, podeu assegurar-vos que els valors no es modifiquin accidentalment, reduint la possibilitat d'errors i errors al vostre codi. Optimització millorada: els compiladors poden optimitzar les variables const de manera més eficaç, ja que saben que els seus valors no canviaran durant l'execució del programa. Això pot donar lloc a un codi més ràpid i eficient. Millor ús de la memòria: en declarar variables com a const, sovint podeu evitar haver de fer una còpia dels seus valors, cosa que pot reduir l'ús de memòria i millorar el rendiment. Compatibilitat millorada: en declarar variables com a const, podeu fer que el vostre codi sigui més compatible amb altres biblioteques i API que utilitzen variables const. Fiabilitat millorada: amb const, podeu fer que el vostre codi sigui més fiable, ja que podeu assegurar-vos que els valors no es modifiquin de manera inesperada, reduint el risc d'errors i errors al vostre codi.
Resum
| Tipus | Declaració | Canvi de valor del punter (*ptr = 100) | Canvi de valor de senyalització (ptr = &a) |
|---|---|---|---|
| Punter a la variable | int * ptr | Sí | Sí |
| Punter a la constant | const int * ptr int const * ptr | No | Sí |
| Punter constant a la variable | int * const ptr | Sí | No |
| Constant Apuntador a constant | const int * const ptr | No | No |
Aquest article està compilat per Narendra Kangralkar .