Der Qualifikant const kann auf die Deklaration einer beliebigen Variablen angewendet werden, um anzugeben, dass ihr Wert nicht geändert wird (was davon abhängt, wo const-Variablen gespeichert sind; wir können den Wert der const-Variablen mithilfe eines Zeigers ändern). Das Ergebnis ist durch die Implementierung definiert, wenn versucht wird, eine Konstante zu ändern.
Die Verwendung des const-Qualifizierers in C ist eine gute Vorgehensweise, wenn wir sicherstellen möchten, dass einige Werte konstant bleiben und nicht versehentlich geändert werden.
Hadoop-Tutorial
In der C-Programmierung kann das Qualifikationsmerkmal const in verschiedenen Kontexten verwendet werden, um verschiedene Verhaltensweisen bereitzustellen. Hier sind einige verschiedene Anwendungsfälle des const-Qualifizierers in C:
1. Konstante Variablen
const int var = 100;>
In diesem Fall wird const zum Deklarieren einer Variablen verwendet War als Konstante mit einem Anfangswert von 100. Der Wert dieser Variablen kann nach der Initialisierung nicht mehr geändert werden. Sehen Sie sich das folgende Beispiel an:
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;> }> |
>
>
Ausgabe
./Solution.cpp: In function 'int main()': ./Solution.cpp:11:9: error: assignment of read-only variable 'var' var = 200; ^>
2. Zeiger auf Konstante
const int* ptr;>
ODER
int const *ptr;>
Wir können den Zeiger so ändern, dass er auf jede andere Ganzzahlvariable zeigt, aber nicht den Wert des Objekts (Entität), auf das mit dem Zeiger ptr gezeigt wird. Der Zeiger wird im Lese-/Schreibbereich (im vorliegenden Fall Stack) gespeichert. Das Objekt, auf das verwiesen wird, kann sich im schreibgeschützten Bereich oder im Lese-/Schreibbereich befinden. Sehen wir uns die folgenden Beispiele an.
Beispiel 1:
C
Selen-Tutorial
// 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;> }> |
>
>
Ausgabe
./Solution.c: In function 'main': ./Solution.c:12:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Beispiel 2: Programm, bei dem die Variable i selbst konstant ist.
C
wie man char in string umwandelt
// 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;> }> |
>
>
Ausgabe
./Solution.c: In function 'main': ./Solution.c:18:10: error: assignment of read-only location '*ptr' *ptr = 100; ^>
Down-Qualifikation ist in C++ nicht zulässig und kann in C zu Warnungen führen. Unter Down-Qualifizierung versteht man die Situation, in der ein qualifizierter Typ einem nicht qualifizierten Typ zugewiesen wird.
Beispiel 3: Programm zum Nachweis der Qualifikation.
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;> }> |
>
>
in Java
Ausgabe
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. Konstanter Zeiger auf Variable
int* const ptr;>
Die obige Deklaration ist ein konstanter Zeiger auf eine Ganzzahlvariable, was bedeutet, dass wir den Wert des Objekts, auf das der Zeiger zeigt, ändern können, den Zeiger jedoch nicht so ändern können, dass er auf eine andere Variable zeigt.
Beispiel
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;> }> |
>
>
Ausgabe
Python-Pfadeinstellung
./Solution.c: In function 'main': ./Solution.c:15:9: error: assignment of read-only variable 'ptr' ptr = &j; /* error */ ^>
4. Konstanter Zeiger auf Konstante
const int* const ptr;>
Die obige Deklaration ist ein konstanter Zeiger auf eine konstante Variable, was bedeutet, dass wir den Wert, auf den der Zeiger zeigt, nicht ändern und den Zeiger nicht auf andere Variablen verweisen können. Sehen wir uns das anhand eines Beispiels an.
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;> }> |
>
>
Ausgabe
./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 */ ^>
Vorteile von const-Qualifizierern in C
Der const-Qualifizierer in C hat die folgenden Vorteile:
- Verbesserte Lesbarkeit des Codes: Indem Sie eine Variable als const markieren, zeigen Sie anderen Programmierern an, dass ihr Wert nicht geändert werden sollte, wodurch Ihr Code leichter zu verstehen und zu warten ist. Verbesserte Typsicherheit: Durch die Verwendung von const können Sie sicherstellen, dass Werte nicht versehentlich geändert werden, wodurch die Wahrscheinlichkeit von Fehlern und Irrtümern in Ihrem Code verringert wird. Verbesserte Optimierung: Compiler können Const-Variablen effektiver optimieren, da sie wissen, dass sich ihre Werte während der Programmausführung nicht ändern. Dies kann zu schnellerem und effizienterem Code führen. Bessere Speichernutzung: Indem Sie Variablen als const deklarieren, können Sie oft vermeiden, dass Sie eine Kopie ihrer Werte erstellen müssen, was die Speichernutzung reduzieren und die Leistung verbessern kann. Verbesserte Kompatibilität: Durch die Deklaration von Variablen als const können Sie Ihren Code kompatibler mit anderen Bibliotheken und APIs machen, die const-Variablen verwenden. Verbesserte Zuverlässigkeit: Durch die Verwendung von const können Sie Ihren Code zuverlässiger machen, da Sie sicherstellen können, dass Werte nicht unerwartet geändert werden, wodurch das Risiko von Fehlern und Fehlern in Ihrem Code verringert wird.
Zusammenfassung
| Typ | Erklärung | Zeigerwertänderung (*ptr = 100) | Zeigerwertänderung (ptr = &a) |
|---|---|---|---|
| Zeiger auf Variable | int * ptr | Ja | Ja |
| Zeiger auf Konstante | const int * ptr int const * ptr | NEIN | Ja |
| Konstanter Zeiger auf Variable | int * const ptr | Ja | NEIN |
| Konstanter Zeiger auf Konstante | const int * const ptr | NEIN | NEIN |
Dieser Artikel wurde zusammengestellt von Narendra Kangralkar .