Kvalifikatorius konst gali būti taikomas bet kurio kintamojo deklaravimui, siekiant nurodyti, kad jo reikšmė nebus pakeista (tai priklauso nuo to, kur saugomi const kintamieji, mes galime pakeisti const kintamojo reikšmę naudodami rodyklę). Rezultatas apibrėžiamas įgyvendinant, jei bandoma pakeisti konst.
Const kvalifikatoriaus naudojimas C yra gera praktika, kai norime užtikrinti, kad kai kurios reikšmės išliktų pastovios ir nebūtų atsitiktinai pakeistos.
c struktūra struktūroje
Programuojant C, const kvalifikatorius gali būti naudojamas įvairiuose kontekstuose, kad būtų galima pateikti įvairius veiksmus. Štai keletas skirtingų const kvalifikatoriaus naudojimo atvejų C:
1. Pastovūs kintamieji
const int var = 100;>
Šiuo atveju const naudojamas kintamajam deklaruoti buvo kaip konstanta, kurios pradinė reikšmė yra 100. Šio kintamojo reikšmės negalima keisti, kai jis inicijuojamas. Žiūrėkite šį pavyzdį:
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;> }> |
>
>
Išvestis
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Nukreipkite žymiklį į Constant
const int* ptr;>
ARBA
int const *ptr;>
Mes galime pakeisti žymeklį, kad jis nukreiptų į bet kurį kitą sveikąjį kintamąjį, bet negalime pakeisti objekto (esybės), nukreipto naudojant žymeklį ptr, reikšmės. Rodyklė saugoma skaitymo ir rašymo srityje (šiuo atveju krūva). Nurodytas objektas gali būti tik skaitymo arba rašymo-skaitymo srityje. Pažiūrėkime toliau pateiktus pavyzdžius.
1 pavyzdys:
C
kaip pervardyti katalogą Linux
// 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;> }> |
>
>
Išvestis
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
2 pavyzdys: programa, kurioje pats kintamasis i yra pastovus.
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;> }> |
>
nuo griežto iki tarpt
>
Išvestis
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Žemesnė kvalifikacija neleidžiamas C++ ir gali sukelti įspėjimus C. Down kvalifikacija reiškia situaciją, kai kvalifikuotas tipas priskiriamas nekvalifikuotam tipui.
3 pavyzdys: programa, skirta parodyti kvalifikaciją.
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;> }> |
>
>
poeilutės metodas java
Išvestis
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. Pastovus rodyklė į kintamąjį
int* const ptr;>
Aukščiau pateikta deklaracija yra pastovi rodyklė į sveikąjį kintamąjį, o tai reiškia, kad galime pakeisti žymeklio nurodyto objekto reikšmę, bet negalime pakeisti žymeklio, kad būtų nukreiptas į kitą kintamąjį.
Pavyzdys
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;> }> |
>
>
Išvestis
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Constant Rodyklė į konstantą
const int* const ptr;>
Aukščiau pateikta deklaracija yra pastovus rodyklė į pastovų kintamąjį, o tai reiškia, kad negalime pakeisti žymeklio nurodytos reikšmės, taip pat negalime nukreipti žymeklio į kitus kintamuosius. Pažiūrėkime su pavyzdžiu.
C
kortele java
// 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;> }> |
>
>
Išvestis
./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 */ ^>
„Const“ kvalifikacijos privalumai C
Const kvalifikatorius C turi šiuos privalumus:
- Patobulintas kodo skaitomumas: pažymėdami kintamąjį kaip const, kitiems programuotojams nurodote, kad jo reikšmės keisti nereikėtų, todėl kodą lengviau suprasti ir prižiūrėti. Patobulinta tipo sauga : naudodami const galite užtikrinti, kad reikšmės nebūtų netyčia pakeistos, sumažinant klaidų ir klaidų tikimybę kode. Patobulintas optimizavimas: Kompiliatoriai gali efektyviau optimizuoti const kintamuosius, nes žino, kad jų reikšmės programos vykdymo metu nepasikeis. Dėl to kodas gali būti greitesnis ir efektyvesnis. Geresnis atminties naudojimas: deklaruodami kintamuosius kaip const, dažnai galite išvengti jų reikšmių kopijos, o tai gali sumažinti atminties naudojimą ir pagerinti našumą. Patobulintas suderinamumas : deklaruodami kintamuosius kaip const, galite padaryti savo kodą labiau suderinamą su kitomis bibliotekomis ir API, kuriose naudojami const kintamieji. Patobulintas patikimumas : naudodami const galite padaryti savo kodą patikimesnį, nes galite užtikrinti, kad reikšmės nebūtų netikėtai pakeistos, taip sumažinant kodo klaidų ir klaidų riziką.
Santrauka
| Tipas | Deklaracija | Rodyklės reikšmės keitimas (*ptr = 100) | Nurodančios vertės pasikeitimas (ptr = &a) |
|---|---|---|---|
| Rodyklė į kintamąjį | int * ptr | Taip | Taip |
| Rodyklė į Constant | const int * ptr int const * ptr | Nr | Taip |
| Nuolatinis rodyklė į kintamąjį | int * const ptr | Taip | Nr |
| Pastovus žymeklis į konstantą | const int * const ptr | Nr | Nr |
Šį straipsnį parengė Narendra Kangralkar .