Kvalet konst kan tillämpas på deklarationen av valfri variabel för att specificera att dess värde inte kommer att ändras (vilket beror på var const-variabler lagras, vi kan ändra värdet på const-variabeln genom att använda en pekare). Resultatet är implementeringsdefinierat om ett försök görs att ändra en konst.
Att använda const-kvalificeraren i C är en bra praxis när vi vill säkerställa att vissa värden ska förbli konstanta och inte av misstag ändras.
js laddas
I C-programmering kan const-kvalificeraren användas i olika sammanhang för att ge olika beteenden. Här är några olika användningsfall av const-kvalet i C:
1. Konstanta variabler
const int var = 100;>
I det här fallet används const för att deklarera en variabel var som en konstant med ett initialt värde på 100. Värdet på denna variabel kan inte ändras när den väl har initierats. Se följande exempel:
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;> }> |
>
>
Produktion
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Pekare till konstant
const int* ptr;>
ELLER
int const *ptr;>
Vi kan ändra pekaren så att den pekar på någon annan heltalsvariabel, men kan inte ändra värdet på objektet (entiteten) som pekas med hjälp av pekaren ptr. Pekaren lagras i läs-skrivområdet (stack i detta fall). Objektet som pekar kan vara i läs- eller läs-skrivområdet. Låt oss se följande exempel.
Exempel 1:
C
typer av nätverk
// 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;> }> |
>
>
Produktion
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Exempel 2: Program där variabeln i själv är konstant.
C
hur man använder mysql workbench
// 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;> }> |
>
>
Produktion
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Nedkvalificering är inte tillåtet i C++ och kan orsaka varningar i C. Nedkvalificering avser situationen där en kvalificerad typ tilldelas en icke-kvalificerad typ.
Exempel 3: Program för att visa ned kvalifikationer.
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;> }> |
>
>
avl träd
Produktion
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 pekare till variabel
int* const ptr;>
Ovanstående deklaration är en konstant pekare till en heltalsvariabel, vilket betyder att vi kan ändra värdet på objektet som pekas av pekaren, men inte ändra pekaren så att den pekar på en annan variabel.
Exempel
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;> }> |
>
>
Produktion
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Konstant pekare till konstant
const int* const ptr;>
Ovanstående deklaration är en konstant pekare till en konstant variabel, vilket betyder att vi inte kan ändra värdet som pekas av pekaren, liksom vi inte kan peka pekaren till andra variabler. Låt oss se med ett exempel.
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;> }> |
>
>
Produktion
maskinskrivet datum och tid
./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 */ ^>
Fördelar med Const Qualifiers i C
Const-kvalet i C har följande fördelar:
- Förbättrad kodläsbarhet: Genom att markera en variabel som const, indikerar du för andra programmerare att dess värde inte bör ändras, vilket gör din kod lättare att förstå och underhålla. Förbättrad typsäkerhet : Genom att använda const kan du säkerställa att värden inte ändras av misstag, vilket minskar risken för buggar och fel i din kod. Förbättrad optimering: Kompilatorer kan optimera const-variabler mer effektivt, eftersom de vet att deras värden inte kommer att ändras under programexekveringen. Detta kan resultera i snabbare och effektivare kod. Bättre minnesanvändning: Genom att deklarera variabler som const kan du ofta undvika att behöva göra en kopia av deras värden, vilket kan minska minnesanvändningen och förbättra prestandan. Förbättrad kompatibilitet : Genom att deklarera variabler som const kan du göra din kod mer kompatibel med andra bibliotek och API:er som använder const-variabler. Förbättrad tillförlitlighet : Genom att använda const kan du göra din kod mer tillförlitlig, eftersom du kan säkerställa att värden inte ändras oväntat, vilket minskar risken för buggar och fel i din kod.
Sammanfattning
| Typ | Deklaration | Pointer Value Change (*ptr = 100) | Pointing Value Change (ptr = &a) |
|---|---|---|---|
| Pekare till variabel | int * ptr | Ja | Ja |
| Pekare till konstant | const int * ptr int const * ptr | Nej | Ja |
| Konstant pekare till variabel | int * const ptr | Ja | Nej |
| Konstant pekare till konstant | const int * const ptr | Nej | Nej |
Denna artikel är sammanställd av Narendra Kangralkar .