Il qualificatore cost può essere applicato alla dichiarazione di qualsiasi variabile per specificare che il suo valore non verrà modificato (che dipende da dove sono memorizzate le variabili const, possiamo modificare il valore della variabile const utilizzando un puntatore). Il risultato è definito dall'implementazione se si tenta di modificare un const.
Usare il qualificatore const in C è una buona pratica quando vogliamo assicurarci che alcuni valori rimangano costanti e non vengano modificati accidentalmente.
alberi divaricati
Nella programmazione C, il qualificatore const può essere utilizzato in diversi contesti per fornire vari comportamenti. Ecco alcuni casi d'uso diversi del qualificatore const in C:
1. Variabili costanti
const int var = 100;>
In questo caso, const viene utilizzato per dichiarare una variabile era come costante con un valore iniziale pari a 100. Il valore di questa variabile non può essere modificato una volta inizializzata. Vedere l'esempio seguente:
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;> }> |
>
>
Produzione
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Puntatore a Costante
const int* ptr;>
O
int const *ptr;>
Possiamo cambiare il puntatore in modo che punti a qualsiasi altra variabile intera, ma non possiamo cambiare il valore dell'oggetto (entità) puntato usando il puntatore ptr. Il puntatore viene memorizzato nell'area di lettura-scrittura (stack nel presente caso). L'oggetto puntato può trovarsi nell'area di sola lettura o di lettura-scrittura. Vediamo i seguenti esempi.
Esempio 1:
C
tipi di rete
// 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;> }> |
>
>
Produzione
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Esempio 2: programma in cui la variabile i stessa è costante.
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;> }> |
inferno di richiamata in javascript
>
>
Produzione
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Qualificazione in calo non è consentito in C++ e può causare avvisi in C. La qualificazione down si riferisce alla situazione in cui un tipo qualificato viene assegnato a un tipo non qualificato.
Esempio 3: programma per mostrare la qualifica.
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;> }> |
>
>
in Giava
Produzione
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. Puntatore costante a variabile
int* const ptr;>
La dichiarazione precedente è un puntatore costante a una variabile intera, il che significa che possiamo modificare il valore dell'oggetto puntato dal puntatore, ma non possiamo modificare il puntatore in modo che punti a un'altra variabile.
Esempio
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;> }> |
>
>
Produzione
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Puntatore costante a costante
const int* const ptr;>
La dichiarazione di cui sopra è un puntatore costante a una variabile costante, il che significa che non possiamo modificare il valore indicato dal puntatore così come non possiamo puntare il puntatore ad altre variabili. Vediamo con un esempio.
C
software di sistema
// 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;> }> |
>
>
Produzione
./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 */ ^>
Vantaggi delle qualificazioni const in C
Il qualificatore const in C presenta i seguenti vantaggi:
- Migliore leggibilità del codice: contrassegnando una variabile come const, indichi ad altri programmatori che il suo valore non deve essere modificato, rendendo il tuo codice più facile da comprendere e mantenere. Sicurezza del tipo migliorata: utilizzando const, puoi garantire che i valori non vengano modificati accidentalmente, riducendo la possibilità di bug ed errori nel codice. Ottimizzazione migliorata: i compilatori possono ottimizzare le variabili const in modo più efficace, poiché sanno che i loro valori non cambieranno durante l'esecuzione del programma. Ciò può comportare un codice più veloce ed efficiente. Migliore utilizzo della memoria: dichiarando le variabili come const, è spesso possibile evitare di dover creare una copia dei relativi valori, riducendo così l'utilizzo della memoria e migliorando le prestazioni. Compatibilità migliorata: dichiarando le variabili come const, puoi rendere il tuo codice più compatibile con altre librerie e API che utilizzano variabili const. Affidabilità migliorata: utilizzando const, puoi rendere il tuo codice più affidabile, poiché puoi garantire che i valori non vengano modificati inaspettatamente, riducendo il rischio di bug ed errori nel tuo codice.
Riepilogo
| Tipo | Dichiarazione | Modifica del valore del puntatore (*ptr = 100) | Modifica del valore di puntamento (ptr = &a) |
|---|---|---|---|
| Puntatore alla variabile | int*ptr | SÌ | SÌ |
| Puntatore a costante | const int * ptr int const * ptr | NO | SÌ |
| Puntatore costante a variabile | int * const ptr | SÌ | NO |
| Puntatore costante a costante | const int * const ptr | NO | NO |
Questo articolo è compilato da Narendra Kangralkar .