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.

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

// 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.

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;> }>

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:

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 .