Kvalifiseringen konst kan brukes på deklarasjonen av en hvilken som helst variabel for å spesifisere at verdien ikke vil bli endret (som avhenger av hvor const-variabler er lagret, vi kan endre verdien til const-variabelen ved å bruke en peker). Resultatet er implementeringsdefinert hvis det gjøres forsøk på å endre en konst.
Å bruke const-kvalifiseringen i C er en god praksis når vi vil sikre at noen verdier skal forbli konstante og ikke må endres ved et uhell.
python generere uuid
I C-programmering kan const-kvalifiseringen brukes i forskjellige sammenhenger for å gi forskjellige atferd. Her er noen forskjellige brukstilfeller av const-kvalifiseringen i C:
1. Konstante variabler
const int var = 100;>
I dette tilfellet brukes const til å erklære en variabel var som en konstant med en startverdi på 100. Verdien til denne variabelen kan ikke endres når den først er initialisert. Se følgende eksempel:
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;> }> |
>
>
Produksjon
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Peker til konstant
const int* ptr;>
ELLER
int const *ptr;>
Vi kan endre pekeren til å peke på en hvilken som helst annen heltallsvariabel, men kan ikke endre verdien til objektet (entiteten) som pekes ved hjelp av pekeren ptr. Pekeren er lagret i lese-skriveområdet (stabel i dette tilfellet). Objektet som pekes kan være i skrivebeskyttet eller lese-skriveområdet. La oss se følgende eksempler.
Eksempel 1:
C
hva står google for
// 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;> }> |
>
>
Produksjon
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Eksempel 2: Program hvor variabel i selv er konstant.
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;> }> |
>
hvor mange byer er det i USA
>
Produksjon
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Nedkvalifisering er ikke tillatt i C++ og kan forårsake advarsler i C. Nedkvalifisering refererer til situasjonen der en kvalifisert type er tildelt en ikke-kvalifisert type.
Eksempel 3: Program for å vise ned kvalifisering.
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;> }> |
>
>
streng sammenligne c#
Produksjon
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. Konstant peker til variabel
int* const ptr;>
Deklarasjonen ovenfor er en konstant peker til en heltallsvariabel, noe som betyr at vi kan endre verdien til objektet pekeren peker på, men kan ikke endre pekeren til en annen variabel.
Eksempel
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;> }> |
>
>
Produksjon
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Konstant peker til konstant
const int* const ptr;>
Deklarasjonen ovenfor er en konstant peker til en konstant variabel, noe som betyr at vi ikke kan endre verdien som pekeren viser, så vel som vi ikke kan peke pekeren til andre variabler. La oss se med et eksempel.
C
strengen er tom
// 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;> }> |
>
>
Produksjon
./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 */ ^>
Fordeler med const Qualifiers i C
Const-kvalifiseringen i C har følgende fordeler:
- Forbedret kodelesbarhet: Ved å merke en variabel som const, indikerer du overfor andre programmerere at verdien ikke bør endres, noe som gjør koden lettere å forstå og vedlikeholde. Forbedret typesikkerhet: Ved å bruke const kan du sikre at verdiene ikke endres ved et uhell, noe som reduserer sjansen for feil og feil i koden din. Forbedret optimalisering: Kompilatorer kan optimalisere const-variabler mer effektivt, da de vet at verdiene deres ikke vil endres under programkjøring. Dette kan resultere i raskere og mer effektiv kode. Bedre minnebruk: Ved å erklære variabler som const, kan du ofte unngå å måtte lage en kopi av verdiene deres, noe som kan redusere minnebruken og forbedre ytelsen. Forbedret kompatibilitet: Ved å erklære variabler som const, kan du gjøre koden din mer kompatibel med andre biblioteker og APIer som bruker const-variabler. Forbedret pålitelighet: Ved å bruke const kan du gjøre koden mer pålitelig, da du kan sikre at verdiene ikke endres uventet, noe som reduserer risikoen for feil og feil i koden.
Sammendrag
| Type | Erklæring | Pekerverdiendring (*ptr = 100) | Pekeverdiendring (ptr = &a) |
|---|---|---|---|
| Peker til variabel | int * ptr | Ja | Ja |
| Peker til konstant | const int * ptr int const * ptr | Nei | Ja |
| Konstant peker til variabel | int * const ptr | Ja | Nei |
| Konstant peker til konstant | const int * const ptr | Nei | Nei |
Denne artikkelen er satt sammen av Narendra Kangralkar .