Kwalifikator konst można zastosować do deklaracji dowolnej zmiennej, aby określić, że jej wartość nie zostanie zmieniona (co zależy od tego, gdzie przechowywane są zmienne const, możemy zmienić wartość zmiennej const za pomocą wskaźnika). Wynik jest zdefiniowany w implementacji, jeśli podjęto próbę zmiany stałej.
Używanie kwalifikatora const w C jest dobrą praktyką, gdy chcemy mieć pewność, że niektóre wartości pozostaną stałe i nie powinny zostać przypadkowo zmodyfikowane.
praca przy komputerze
W programowaniu w C kwalifikator const może być używany w różnych kontekstach, aby zapewnić różne zachowania. Oto kilka różnych przypadków użycia kwalifikatora const w C:
1. Zmienne stałe
const int var = 100;>
W tym przypadku const służy do deklarowania zmiennej był jako stała o wartości początkowej 100. Wartość tej zmiennej nie może być modyfikowana po jej zainicjowaniu. Zobacz następujący przykład:
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;> }> |
>
>
Wyjście
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Wskaźnik do stałej
const int* ptr;>
LUB
int const *ptr;>
Możemy zmienić wskaźnik tak, aby wskazywał dowolną inną zmienną całkowitą, ale nie możemy zmienić wartości obiektu (bytu) wskazanego za pomocą wskaźnika ptr. Wskaźnik jest przechowywany w obszarze odczytu i zapisu (w tym przypadku stosu). Wskazany obiekt może znajdować się w obszarze tylko do odczytu lub do odczytu i zapisu. Zobaczmy następujące przykłady.
Przykład 1:
C
Java pgm
// 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;> }> |
>
>
Wyjście
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Przykład 2: Program, w którym sama zmienna i jest stała.
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;> }> |
>
>
katalog w poleceniach systemu Linux
Wyjście
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Kwalifikacja w dół nie jest dozwolone w C++ i może powodować ostrzeżenia w C. Kwalifikacja w dół odnosi się do sytuacji, w której typ kwalifikowany jest przypisany do typu niekwalifikowanego.
Przykład 3: Program pokazujący kwalifikacje.
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;> }> |
>
>
globalna zmienna w js
Wyjście
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. Stały wskaźnik do zmiennej
int* const ptr;>
Powyższa deklaracja jest stałym wskaźnikiem do zmiennej całkowitej, co oznacza, że możemy zmienić wartość obiektu wskazywanego przez wskaźnik, ale nie możemy zmienić wskaźnika tak, aby wskazywał inną zmienną.
Przykład
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;> }> |
>
>
Wyjście
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Stała Wskaźnik na stałą
const int* const ptr;>
Powyższa deklaracja jest stałym wskaźnikiem na stałą zmienną, co oznacza, że nie możemy zmienić wartości wskazywanej przez wskaźnik, a także nie możemy wskazać wskaźnika na inne zmienne. Zobaczmy na przykładzie.
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;> }> |
>
rodzaje uczenia maszynowego
>
Wyjście
./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 */ ^>
Zalety kwalifikatorów const w C
Kwalifikator const w C ma następujące zalety:
- Poprawiona czytelność kodu: Oznaczając zmienną jako stałą, wskazujesz innym programistom, że jej wartość nie powinna być zmieniana, co ułatwia zrozumienie i utrzymanie kodu. Zwiększone bezpieczeństwo typów: używając const, możesz mieć pewność, że wartości nie zostaną przypadkowo zmodyfikowane, zmniejszając ryzyko błędów w kodzie. Ulepszona optymalizacja: Kompilatory mogą skuteczniej optymalizować zmienne const, ponieważ wiedzą, że ich wartości nie ulegną zmianie podczas wykonywania programu. Może to skutkować szybszym i wydajniejszym kodem. Lepsze wykorzystanie pamięci: Deklarując zmienne jako const, często można uniknąć konieczności tworzenia kopii ich wartości, co może zmniejszyć zużycie pamięci i poprawić wydajność. Poprawiona kompatybilność: deklarując zmienne jako const, możesz uczynić swój kod bardziej kompatybilnym z innymi bibliotekami i interfejsami API, które używają zmiennych const. Większa niezawodność: używając const, możesz zwiększyć niezawodność swojego kodu, ponieważ możesz mieć pewność, że wartości nie zostaną nieoczekiwanie zmodyfikowane, zmniejszając ryzyko błędów w kodzie.
Streszczenie
| Typ | Deklaracja | Zmiana wartości wskaźnika (*ptr = 100) | Zmiana wartości wskazującej (ptr = &a) |
|---|---|---|---|
| Wskaźnik do zmiennej | int * pt | Tak | Tak |
| Wskaźnik do stałej | stała int * pt int stała * pt | NIE | Tak |
| Stały wskaźnik do zmiennej | int * stała pt | Tak | NIE |
| Stała Wskaźnik do stałej | stała int * stała ptr | NIE | NIE |
Ten artykuł został opracowany przez Narendrę Kangralkara .