Kvalifikátor konšt možno použiť na deklaráciu akejkoľvek premennej, aby sme určili, že jej hodnota sa nezmení (čo závisí od toho, kde sú uložené premenné const, hodnotu premennej const môžeme zmeniť pomocou ukazovateľa). Výsledok je definovaný implementáciou, ak sa vykoná pokus o zmenu konšt.
Použitie kvalifikátora const v C je dobrou praxou, keď chceme zabezpečiť, aby niektoré hodnoty zostali konštantné a nemali by sa náhodne meniť.
numpy dot produkt
V programovaní v jazyku C môže byť kvalifikátor const použitý v rôznych kontextoch na poskytovanie rôznych správaní. Tu je niekoľko rôznych prípadov použitia kvalifikátora const v C:
1. Konštantné premenné
const int var = 100;>
V tomto prípade sa const používa na deklarovanie premennej bol ako konštanta s počiatočnou hodnotou 100. Hodnotu tejto premennej nemožno po inicializácii zmeniť. Pozrite si nasledujúci príklad:
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;> }> |
>
>
Výkon
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Ukazovateľ na konštantu
const int* ptr;>
ALEBO
int const *ptr;>
Ukazovateľ môžeme zmeniť tak, aby ukazoval na akúkoľvek inú celočíselnú premennú, ale nemôžeme zmeniť hodnotu objektu (entity), na ktorý ukazuje ukazovateľ ptr. Ukazovateľ je uložený v oblasti čítania a zápisu (v tomto prípade zásobníka). Ukazovaný objekt môže byť v oblasti len na čítanie alebo na čítanie a zápis. Pozrime sa na nasledujúce príklady.
Príklad 1:
C
typy sietí
// 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;> }> |
>
>
Výkon
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Príklad 2: Program, kde samotná premenná i je konštantná.
C
v ktorom roku bol vynájdený počítač
// 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;> }> |
>
>
Výkon
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Dolná kvalifikácia nie je povolená v C++ a môže spôsobiť varovania v C. Pod kvalifikáciou sa rozumie situácia, keď je kvalifikovaný typ priradený nekvalifikovanému typu.
Príklad 3: Program na preukázanie kvalifikácie.
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;> }> |
>
>
podreťazec java obsahuje
Výkon
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. Konštantný ukazovateľ na premennú
int* const ptr;>
Vyššie uvedená deklarácia je konštantný ukazovateľ na celočíselnú premennú, čo znamená, že môžeme zmeniť hodnotu objektu, na ktorý ukazuje ukazovateľ, ale nemôžeme zmeniť ukazovateľ tak, aby ukazoval na inú premennú.
Príklad
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;> }> |
>
príklad java mapy
>
Výkon
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Konštantný ukazovateľ na konštantu
const int* const ptr;>
Vyššie uvedená deklarácia je konštantný ukazovateľ na konštantnú premennú, čo znamená, že nemôžeme zmeniť hodnotu, na ktorú ukazuje ukazovateľ, rovnako ako nemôžeme smerovať ukazovateľ na iné premenné. Pozrime sa na príklade.
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;> }> |
>
>
Výkon
./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 */ ^>
Výhody konštantných kvalifikácií v C
Kvalifikátor const v C má nasledujúce výhody:
- Vylepšená čitateľnosť kódu: Označením premennej ako const dáte ostatným programátorom najavo, že jej hodnota by sa nemala meniť, čo uľahčuje pochopenie a údržbu vášho kódu. Vylepšená bezpečnosť typu: Použitím const môžete zaistiť, že hodnoty nebudú náhodne zmenené, čím sa zníži pravdepodobnosť chýb a chýb vo vašom kóde. Vylepšená optimalizácia: Kompilátory môžu efektívnejšie optimalizovať premenné const, pretože vedia, že ich hodnoty sa počas vykonávania programu nezmenia. Výsledkom môže byť rýchlejší a efektívnejší kód. Lepšie využitie pamäte: Deklarovaním premenných ako const sa často môžete vyhnúť tomu, aby ste museli vytvárať kópiu ich hodnôt, čo môže znížiť využitie pamäte a zlepšiť výkon. Vylepšená kompatibilita: Deklarovaním premenných ako const môžete zvýšiť kompatibilitu svojho kódu s inými knižnicami a rozhraniami API, ktoré používajú premenné const. Vylepšená spoľahlivosť: Použitím const môžete urobiť svoj kód spoľahlivejším, pretože môžete zaistiť, že hodnoty nebudú neočakávane zmenené, čím sa zníži riziko chýb a chýb vo vašom kóde.
Zhrnutie
| Typ | Vyhlásenie | Zmena hodnoty ukazovateľa (*ptr = 100) | Zmena hodnoty smerovania (ptr = &a) |
|---|---|---|---|
| Ukazovateľ na premennú | int * ptr | Áno | Áno |
| Ukazovateľ na konštantu | const int * ptr int const * ptr | Nie | Áno |
| Konštantný ukazovateľ na premennú | int * const ptr | Áno | Nie |
| Konštantný ukazovateľ na konštantu | const int * const ptr | Nie | Nie |
Tento článok zostavuje Narendra Kangralkar .