In diesem Artikel haben wir den Unterschied zwischen *- und **-Zeigern in C und C++ erklärt.
Inhaltsverzeichnis:
1. Was sind Zeiger?
2. Beispiele für Zeiger
3. Implementierung von Zeigern mit C
4. *p gegenüber **p Zeiger
5. Implementierung von *p und **p mit C
Was sind Zeiger?
Pointer ist eine Variable, die verwendet wird, um die Adresse im Speicher einer anderen Variablen zu speichern.
Die beiden in den Zeigern verwendeten Operatoren:
- Operator &:- Gibt die Adresse einer Variablen an
- Operator * :- Gibt die Werte an Ort aus
Einige Punkte:
- Adresse darf nicht negativ sein.
- Zeigervariable benötigt dieselben Bytes an Speicher, unabhängig von ihrem Datentyp.
- Die Größe der Pointer-Variablen ist je nach Betriebssystem von System zu System unterschiedlich.
- Zeigervariable kann dereferenzieren nein. Bytes je nach Datentyp.
* Ganzzahlzeiger können zwei Datenbytes dereferenzieren.
* Der Zeichenzeiger kann auf ein Datenbyte zugreifen.
* Float-Zeiger kann auf vier Datenbytes zugreifen. - Zeigervariable wird mit '*'(Sternchen) deklariert.
Beispiele für Zeiger:
int * p ; // Declaration of pointer ‘p’
int a = 10 ;
p = &a ; //Assigning
//now pointer ‘p’ is pointing at variable ‘a’.
Hier deklarieren und weisen wir den Speicherblock 'a' einem Zeiger 'p' zu.
- ‚p‘ ist die Zeigervariable vom Typ Integer, in der wir die Adresse einer beliebigen Integer-Variablen speichern können.
- ‘a‘ ist eine Integer-Variable, die den Wert 10 speichert.
int * p ;
int a = 10 , b ;
b = &a ; //ERROR
Hier sehen wir einen Fehler, weil wir versuchen, die Adresse einer Ganzzahl „a“ in einer anderen Ganzzahl „b“ zu speichern
int a = 10 ;
printf(" a = %d " , * &a ); // output will be a = 10
Hier drucken wir den Wert von 'a', indem wir ihn als Zeiger darstellen. Sagen Sie einfach a=``*&a .
int * p ;
int a = 10 ;
p = &a ;
printf(" %d " , a * p ) ; // ERROR
printf(" %d " , a * * p ); // No ERROR
Hier sehen wir einen ERROR, weil 'a' einen Wert (=10) und *p hat hat auch einen Wert (=10), aber der Compiler wird verwirrt sein, was wir tun wollen, weil der Compiler es als printf(" %d ", (a) (*p) sieht ) ); , gibt es keine arithmetischen Operatoren für den Compiler.
Aber in der nächsten printf()-Anweisung sehen wir keinen FEHLER, da der Compiler jetzt eine Ausgabe als 100 ausgibt, während wir die Multiplikation von 'a' und *p durchführen und beide enthalten einen Wert (=10).
Implementierung von Zeigern mit C
#include<stdio.h>
int main(){
int a=10;
int * p = &a ;
printf(" a = %d \n " , * p ) ; // It gives output a = 10
printf(" Address of a = %p \n ", p ) ; // It gives output Address of a
printf(" Address of p = %p \n ", & p ) ; // It gives output Address of p
return 0;
}
Hier drucken wir den Wert von 'a' und die Adresse von 'a' und 'p'.
Ausgabe:
a = 10
Address of a = 000000000061FE1C
Address of p = 000000000061FE10
*p vs. **p Zeiger
*p ist ein Zeiger, dh er enthält eine Adresse eines Wertes oder einen reservierten Speicherblock. Er kann auf bis zu einer Ebene zugreifen.
Es wird verwendet, wenn Sie einen Speicherblock behalten möchten, in dem sich Ihre Werte befinden.
**p ist ein Zeiger auf einen Zeiger, dh er enthält eine Adresse, die eine Adresse eines Werts oder einen reservierten Speicherblock enthält. Er kann auf bis zu zwei Ebenen zugreifen.
Es wird verwendet, wenn Sie einen Zeiger übergeben möchten, dessen Speicher in einer anderen Funktion zugewiesen wird.
#include<stdio.h>
int main(){
int a=10;
int * p = & a ; // b is a single pointer or a pointer
int ** c = &p; // c is a double pointer or pointer to a pointer
printf("using p \n ");
printf(" value of a = %d \n " , * p ) ; // It gives output value of a = 10
printf(" Address of a = %p \n ", p ) ; // It gives output Address of a
printf(" Address of p = %p \n", & p ) ; // It gives output Address of p
printf("using c \n ");
printf(" value of a = %d \n ", ** c ) ; // It gives output value of a
printf(" Address of a = %p \n ", * c ) ; // It gives output Address of a
printf(" Address of c = %p \n ", &c ) ; // It gives output Address of c
printf(" Address of p = %p \n ", c ) ; // It gives output Address of p
return 0;
}
Hier drucken wir die Werte und Adressen mit einem Zeiger und einem Doppelzeiger.
Ausgabe:
using p
value of a = 10
Address of a = 000000000061FE1C
Address of p = 000000000061FE10
using c
value of a = 10
Address of a = 000000000061FE1C
Address of c = 000000000061FE08
Address of p = 000000000061FE10
Implementierung von *p und **p mit C
#include<stdio.h>
void swap(int * x ,int * y ){
int t = * x ;
* x = * y ;
* y = t ;
}
int main(){
int a = 10 , b = 20 ;
printf(" Value of 'a' before swap = %d \n", a );
printf(" Value of 'b' before swap = %d \n", b );
swap( & a , & b ) ; //function call
printf(" Value of 'a' after swap = %d \n", a );
printf(" Value of 'b' after swap = %d \n", b );
return 0;
}
Hier vertauschen wir zwei Zahlen Zeiger verwenden.
Beim Aufruf der Funktion swap() senden wir die Adressen von Speicherblöcken (d. h. a, b) und um diese Adressen zu übernehmen, nehmen wir ganzzahlige Zeiger als Argumente in swap() (d. h. x, y).
In der Funktion swap() tauschen wir die Werte der Adressen aus.
Ausgabe:
Value of 'a' before swap = 10
Value of 'b' before swap = 20
Value of 'a' after swap = 20
Value of 'b' after swap = 10
#include<stdio.h>
void func(int ** p1 )
{
int b = 2;
* p1 = & b;
}
int main()
{
int a = 10;
int * p = &a;
printf("Before the function, value of the p : %d \n", * p) ;
func(&p); //function Call
printf("After the function, new value of the p : %d \n", * p) ;
return 0;
}
Hier nehmen wir zuerst eine Ganzzahl 'a' und weisen ihr den Wert 10 zu,
Nehmen Sie dann einen Integer-Zeiger 'p' und weisen Sie 'p' die Adresse von 'a' zu.
Jetzt geben wir beim Funktionsaufruf func() die Adresse von 'p' an, das ein Zeiger ist, um die Adresse eines Zeigers zu nehmen, sollte die Funktion func() einen ganzzahligen Zeiger auf einen Zeiger als Argument haben (d. h. p1 in func (p1) ).
In func() ändern wir den Wert von 10 auf 2.
Ausgabe:
Before the function, value of the p : 10
After the function, new value of the p : 2
Mit diesem Artikel bei OpenGenus müssen Sie die vollständige Vorstellung von * vs ** Pointer in C haben.