Calificatorul const poate fi aplicat declarației oricărei variabile pentru a specifica faptul că valoarea acesteia nu va fi modificată (care depinde de locul în care sunt stocate variabilele const, putem modifica valoarea variabilei const folosind un pointer). Rezultatul este definit de implementare dacă se încearcă modificarea unei const.
Utilizarea calificatorului const în C este o practică bună atunci când dorim să ne asigurăm că unele valori ar trebui să rămână constante și să nu fie modificate accidental.
funcții în c
În programarea C, calificativul const poate fi folosit în diferite contexte pentru a oferi diferite comportamente. Iată câteva cazuri de utilizare diferite ale calificatorului const în C:
1. Variabile constante
const int var = 100;>
În acest caz, const este folosit pentru a declara o variabilă a fost ca o constantă cu o valoare inițială de 100. Valoarea acestei variabile nu poate fi modificată odată ce este inițializată. Vezi următorul exemplu:
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;> }> |
>
>
Ieșire
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Indicator către Constant
const int* ptr;>
SAU
int const *ptr;>
Putem schimba indicatorul pentru a indica orice altă variabilă întreagă, dar nu putem schimba valoarea obiectului (entității) indicat folosind pointerul ptr. Pointerul este stocat în zona de citire-scriere (stiva în cazul de față). Obiectul indicat poate fi în zona de numai citire sau de citire-scriere. Să vedem următoarele exemple.
Exemplul 1:
C
char to string java
// 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;> }> |
>
>
Ieșire
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Exemplul 2: Program în care variabila i însăși este 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;> }> |
python este numeric
>
>
Ieșire
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Calificare în jos nu este permisă în C++ și poate provoca avertismente în C. Calificarea în jos se referă la situația în care un tip calificat este atribuit unui tip necalificat.
Exemplul 3: Program pentru a arăta calificarea.
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;> }> |
>
>
char la int java
Ieșire
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. Indicator constant către variabilă
int* const ptr;>
Declarația de mai sus este un pointer constant către o variabilă întreagă, ceea ce înseamnă că putem schimba valoarea obiectului indicat de indicator, dar nu putem schimba pointerul pentru a indica o altă variabilă.
Exemplu
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;> }> |
>
>
Ieșire
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Constant Pointer către constantă
const int* const ptr;>
Declarația de mai sus este un pointer constant către o variabilă constantă, ceea ce înseamnă că nu putem modifica valoarea indicată de indicator, precum și nu putem îndrepta pointerul către alte variabile. Să vedem cu un exemplu.
C
bou vs taur
// 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;> }> |
>
>
Ieșire
./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 */ ^>
Avantajele calificărilor const în C
Calificatorul const în C are următoarele avantaje:
- Lizibilitate îmbunătățită a codului: prin marcarea unei variabile ca const, indicați altor programatori că valoarea acesteia nu trebuie modificată, făcând codul mai ușor de înțeles și de întreținut. Siguranță îmbunătățită a tipului: prin utilizarea const, vă puteți asigura că valorile nu sunt modificate accidental, reducând șansa de erori și erori în codul dvs. Optimizare îmbunătățită: compilatorii pot optimiza mai eficient variabilele const, deoarece știu că valorile lor nu se vor schimba în timpul execuției programului. Acest lucru poate duce la un cod mai rapid și mai eficient. Utilizare mai bună a memoriei: prin declararea variabilelor ca const, puteți evita adesea să fie nevoie să faceți o copie a valorilor acestora, ceea ce poate reduce utilizarea memoriei și poate îmbunătăți performanța. Compatibilitate îmbunătățită: prin declararea variabilelor ca const, puteți face codul mai compatibil cu alte biblioteci și API-uri care folosesc variabile const. Fiabilitate îmbunătățită: Folosind const, puteți face codul mai fiabil, deoarece vă puteți asigura că valorile nu sunt modificate în mod neașteptat, reducând riscul de erori și erori în cod.
rezumat
| Tip | Declaraţie | Modificarea valorii indicatorului (*ptr = 100) | Schimbarea valorii de indicare (ptr = &a) |
|---|---|---|---|
| Indicator către variabilă | int * ptr | da | da |
| Indicator către Constant | const int * ptr int const * ptr | Nu | da |
| Indicator constant către variabilă | int * const ptr | da | Nu |
| Constant Indicator către Constant | const int * const ptr | Nu | Nu |
Acest articol este compilat de Narendra Kangralkar .