Kvalifikátor konst lze použít na deklaraci libovolné proměnné a určit, že se její hodnota nezmění (což závisí na tom, kde jsou proměnné const uloženy, hodnotu proměnné const můžeme změnit pomocí ukazatele). Výsledek je definován implementací, pokud je učiněn pokus o změnu konst.
Použití kvalifikátoru const v C je dobrým zvykem, když chceme zajistit, aby některé hodnoty zůstaly konstantní a neměly by být náhodně změněny.
ins klíč
V programování v jazyce C lze kvalifikátor const použít v různých kontextech k zajištění různého chování. Zde je několik různých případů použití kvalifikátoru const v C:
1. Konstantní proměnné
const int var = 100;>
V tomto případě se k deklaraci proměnné používá const byl jako konstantu s počáteční hodnotou 100. Hodnotu této proměnné nelze po inicializaci změnit. Viz následující pří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ýstup
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Ukazatel na Konstantu
const int* ptr;>
NEBO
int const *ptr;>
Můžeme změnit ukazatel tak, aby ukazoval na jakoukoli jinou celočíselnou proměnnou, ale nemůžeme změnit hodnotu objektu (entity), na kterou ukazuje ukazatel pomocí ukazatele ptr. Ukazatel je uložen v oblasti čtení a zápisu (v tomto případě zásobníku). Ukazovaný objekt může být v oblasti pouze pro čtení nebo pro čtení i pro zápis. Podívejme se na následující příklady.
Příklad 1:
C
selenový tutoriál
// 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ýstup
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Příklad 2: Program, kde samotná proměnná i je konstantní.
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;> }> |
>
>
Výstup
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Kvalifikace dolů není povoleno v C++ a může způsobit varování v C. Kvalifikace Down se týká situace, kdy je kvalifikovaný typ přiřazen nekvalifikovanému typu.
Příklad 3: Program pro zobrazení kvalifikace.
C
junit testovací případy
// 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;> }> |
>
>
pro smyčku java
Výstup
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. Konstantní ukazatel na proměnnou
int* const ptr;>
Výše uvedená deklarace je konstantní ukazatel na celočíselnou proměnnou, což znamená, že můžeme změnit hodnotu objektu, na který ukazuje ukazatel, ale nemůžeme změnit ukazatel tak, aby ukazoval na jinou proměnnou.
Pří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;> }> |
>
>
Výstup
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Konstantní ukazatel na konstantu
const int* const ptr;>
Výše uvedená deklarace je konstantní ukazatel na konstantní proměnnou, což znamená, že nemůžeme měnit hodnotu, na kterou ukazuje ukazatel, stejně jako nemůžeme ukazatel ukazovat na jiné proměnné. Podívejme se na příklad.
halda a halda třídit
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ýstup
./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 const kvalifikací v C
Kvalifikátor const v C má následující výhody:
- Vylepšená čitelnost kódu: Označením proměnné jako const dáváte ostatním programátorům najevo, že její hodnota by se neměla měnit, což usnadňuje pochopení a údržbu vašeho kódu. Vylepšená bezpečnost typu: Pomocí const můžete zajistit, že hodnoty nebudou náhodně změněny, čímž se sníží pravděpodobnost chyb a chyb ve vašem kódu. Vylepšená optimalizace: Kompilátory mohou optimalizovat proměnné const efektivněji, protože vědí, že jejich hodnoty se během provádění programu nezmění. Výsledkem může být rychlejší a efektivnější kód. Lepší využití paměti: Deklarováním proměnných jako const se často můžete vyhnout nutnosti vytvářet kopie jejich hodnot, což může snížit využití paměti a zlepšit výkon. Vylepšená kompatibilita: Deklarováním proměnných jako const můžete zvýšit kompatibilitu kódu s jinými knihovnami a rozhraními API, které používají proměnné const. Vylepšená spolehlivost: Použitím const můžete zvýšit spolehlivost kódu, protože můžete zajistit, že hodnoty nebudou neočekávaně změněny, čímž se sníží riziko chyb a chyb ve vašem kódu.
souhrn
| Typ | Prohlášení | Změna hodnoty ukazatele (*ptr = 100) | Změna hodnoty ukazování (ptr = &a) |
|---|---|---|---|
| Ukazatel na proměnnou | int * ptr | Ano | Ano |
| Ukazatel na Constant | const int * ptr int const * ptr | Ne | Ano |
| Konstantní ukazatel na proměnnou | int * konst ptr | Ano | Ne |
| Konstantní ukazatel na konstantu | const int * const ptr | Ne | Ne |
Tento článek je sestaven společností Narendra Kangralkar .