Karsinta konst voidaan soveltaa minkä tahansa muuttujan ilmoitukseen sen määrittämiseksi, että sen arvoa ei muuteta (joka riippuu siitä, mihin const-muuttujat on tallennettu, voimme muuttaa const-muuttujan arvoa osoittimen avulla). Tulos on toteutusmääritelmä, jos yritetään muuttaa konstia.
Const-määritteen käyttö C:ssä on hyvä käytäntö, kun haluamme varmistaa, että jotkin arvot pysyvät vakioina eikä niitä saa muuttaa vahingossa.
java trimmausmerkkijono
C-ohjelmoinnissa const-tunnistetta voidaan käyttää eri yhteyksissä erilaisten käyttäytymismallien tarjoamiseen. Tässä on joitain erilaisia käyttötapauksia const-määrittimelle C:ssä:
1. Vakiomuuttujat
const int var = 100;>
Tässä tapauksessa const käytetään muuttujan ilmoittamiseen oli vakiona, jonka alkuarvo on 100. Tämän muuttujan arvoa ei voi muuttaa, kun se on alustettu. Katso seuraava esimerkki:
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;> }> |
>
>
Lähtö
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Osoitin vakioon
const int* ptr;>
TAI
int const *ptr;>
Voimme muuttaa osoittimen osoittamaan mihin tahansa muuhun kokonaislukumuuttujaan, mutta emme voi muuttaa objektin (entiteetin) arvoa, joka osoitti osoittimella ptr. Osoitin tallennetaan luku-kirjoitusalueelle (pino tässä tapauksessa). Osoitettu objekti voi olla vain luku- tai luku-kirjoitusalueella. Katsotaanpa seuraavat esimerkit.
Esimerkki 1:
C
char merkkijonoon java
// 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;> }> |
>
>
Lähtö
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Esimerkki 2: Ohjelma, jossa muuttuja i itse on vakio.
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;> }> |
>
>
Lähtö
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Alempi pätevyys ei ole sallittu C++:ssa ja se voi aiheuttaa varoituksia C:ssä. Downin hyväksyntä viittaa tilanteeseen, jossa hyväksytty tyyppi määritetään ei-hyväksyttyyn tyyppiin.
sql satunnaisessa järjestyksessä
Esimerkki 3: Ohjelma pätevyyden osoittamiseksi.
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;> }> |
>
>
javassa
Lähtö
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. Jatkuva osoitin muuttujaan
int* const ptr;>
Yllä oleva ilmoitus on vakio osoitin kokonaislukumuuttujaan, mikä tarkoittaa, että voimme muuttaa osoittimen osoittaman objektin arvoa, mutta emme voi muuttaa osoitinta osoittamaan toiseen muuttujaan.
Esimerkki
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;> }> |
>
>
Lähtö
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Vakioosoitin vakioon
const int* const ptr;>
Yllä oleva ilmoitus on vakioosoitin vakiomuuttujaan, mikä tarkoittaa, että emme voi muuttaa osoittimen osoittamaa arvoa, emmekä voi osoittaa osoitinta muihin muuttujiin. Katsotaanpa esimerkillä.
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;> }> |
>
>
Lähtö
./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-karsinnan edut C:ssä
Const-karsinnassa C:ssä on seuraavat edut:
lihavoitu teksti css:ssä
- Parannettu koodin luettavuus: Merkitsemällä muuttujan const, osoitat muille ohjelmoijille, että sen arvoa ei pidä muuttaa, mikä helpottaa koodin ymmärtämistä ja ylläpitoa. Parannettu tyyppiturvallisuus: Käyttämällä const-toimintoa voit varmistaa, että arvoja ei muuteta vahingossa, mikä vähentää virheiden mahdollisuutta koodissasi. Parannettu optimointi: Kääntäjät voivat optimoida const-muuttujia tehokkaammin, koska he tietävät, että niiden arvot eivät muutu ohjelman suorittamisen aikana. Tämä voi johtaa nopeampaan ja tehokkaampaan koodiin. Parempi muistin käyttö: Ilmoittamalla muuttujat const-muodossa, voit usein välttää niiden arvojen kopioimisen, mikä voi vähentää muistin käyttöä ja parantaa suorituskykyä. Parannettu yhteensopivuus: Määrittämällä muuttujat const-muotoon, voit tehdä koodistasi yhteensopivamman muiden const-muuttujia käyttävien kirjastojen ja sovellusliittymien kanssa. Parempi luotettavuus: Const-sovelluksella voit tehdä koodistasi luotettavamman, koska voit varmistaa, että arvoja ei muuteta odottamatta, mikä vähentää virheiden riskiä koodissasi.
Yhteenveto
| Tyyppi | julistus | Osoittimen arvon muutos (*ptr = 100) | Osoitusarvon muutos (ptr = &a) |
|---|---|---|---|
| Osoitin muuttujaan | int * ptr | Joo | Joo |
| Osoitin vakioon | const int * ptr int const * ptr | Ei | Joo |
| Jatkuva osoitin muuttujaan | int * const ptr | Joo | Ei |
| Vakioosoitin vakioon | const int * const ptr | Ei | Ei |
Tämän artikkelin on koonnut Narendra Kangralkar .