De kwalificatie const kan worden toegepast op de declaratie van elke variabele om te specificeren dat de waarde ervan niet zal worden gewijzigd (wat afhangt van waar const-variabelen zijn opgeslagen, we kunnen de waarde van de const-variabele wijzigen door een pointer te gebruiken). Het resultaat is implementatiegedefinieerd als er wordt geprobeerd een const. te wijzigen.
Het gebruik van de const-kwalificatie in C is een goede gewoonte als we ervoor willen zorgen dat sommige waarden constant blijven en niet per ongeluk worden gewijzigd.
hoeveel steden zijn er in de verenigde staten
Bij C-programmering kan de const-kwalificatie in verschillende contexten worden gebruikt om verschillende gedragingen te bieden. Hier zijn enkele verschillende gebruiksscenario's van de const-kwalificatie in C:
1. Constante variabelen
const int var = 100;>
In dit geval wordt const gebruikt om een variabele te declareren was als een constante met een initiële waarde van 100. De waarde van deze variabele kan niet meer worden gewijzigd nadat deze is geïnitialiseerd. Zie het volgende voorbeeld:
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;> }> |
>
>
Uitvoer
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Wijzer naar Constant
const int* ptr;>
OF
int const *ptr;>
We kunnen de pointer zo veranderen dat hij naar een andere integer-variabele verwijst, maar we kunnen de waarde van het object (entiteit) waarnaar wordt verwezen met pointer ptr niet veranderen. De aanwijzer wordt opgeslagen in het lees-schrijfgebied (in dit geval stack). Het aangewezen object bevindt zich mogelijk in het alleen-lezen- of lees-schrijfgebied. Laten we de volgende voorbeelden bekijken.
Voorbeeld 1:
C
selenium tutorial
// 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;> }> |
>
>
Uitvoer
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Voorbeeld 2: Programma waarbij variabele i zelf constant is.
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;> }> |
>
>
Uitvoer
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Down-kwalificatie is niet toegestaan in C++ en kan waarschuwingen veroorzaken in C. Downkwalificatie verwijst naar de situatie waarin een gekwalificeerd type wordt toegewezen aan een niet-gekwalificeerd type.
Voorbeeld 3: Programma om kwalificatie weer te geven.
C
postordertraject
// 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;> }> |
>
>
tekenreeks vergelijken c#
Uitvoer
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. Constante aanwijzer naar variabele
int* const ptr;>
De bovenstaande declaratie is een constante pointer naar een integer-variabele, wat betekent dat we de waarde van het object waarnaar de pointer wijst, kunnen veranderen, maar de pointer niet kunnen veranderen om naar een andere variabele te verwijzen.
Voorbeeld
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;> }> |
>
>
Uitvoer
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Constante aanwijzer naar constante
const int* const ptr;>
De bovenstaande declaratie is een constante pointer naar een constante variabele, wat betekent dat we de waarde die door de pointer wordt aangegeven niet kunnen veranderen, en ook niet dat we de pointer naar andere variabelen kunnen verwijzen. Laten we eens kijken met een voorbeeld.
C
datalinklaagprotocollen
// 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;> }> |
>
>
Uitvoer
./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 */ ^>
Voordelen van const Qualifiers in C
De const-kwalificatie in C heeft de volgende voordelen:
- Verbeterde leesbaarheid van de code: Door een variabele als const te markeren, geeft u aan andere programmeurs aan dat de waarde ervan niet mag worden gewijzigd, waardoor uw code gemakkelijker te begrijpen en te onderhouden is. Verbeterde typeveiligheid: door const te gebruiken, kunt u ervoor zorgen dat waarden niet per ongeluk worden gewijzigd, waardoor de kans op bugs en fouten in uw code wordt verkleind. Verbeterde optimalisatie: compilers kunnen const-variabelen effectiever optimaliseren, omdat ze weten dat hun waarden niet zullen veranderen tijdens de uitvoering van het programma. Dit kan resulteren in snellere en efficiëntere code. Beter geheugengebruik: Door variabelen als const te declareren, kunt u vaak voorkomen dat u een kopie van hun waarden moet maken, wat het geheugengebruik kan verminderen en de prestaties kan verbeteren. Verbeterde compatibiliteit: door variabelen als const te declareren, kunt u uw code beter compatibel maken met andere bibliotheken en API's die const-variabelen gebruiken. Verbeterde betrouwbaarheid: Door const te gebruiken, kunt u uw code betrouwbaarder maken, omdat u ervoor kunt zorgen dat waarden niet onverwachts worden gewijzigd, waardoor het risico op bugs en fouten in uw code wordt verkleind.
Samenvatting
| Type | Verklaring | Aanwijzerwaarde wijzigen (*pt = 100) | Wijzende waardeverandering (ptr = &a) |
|---|---|---|---|
| Aanwijzer naar variabele | int * ptr | Ja | Ja |
| Wijzer naar Constant | const int * ptr int const * ptr | Nee | Ja |
| Constante aanwijzer naar variabele | int * const ptr | Ja | Nee |
| Constante aanwijzer naar Constant | const int * const ptr | Nee | Nee |
Dit artikel is samengesteld door Narendra Kangralkar .