Pointer in C:Was ist Pointer in der C-Programmierung? Typen

Was ist Pointer in C?

Der Zeiger in C, ist eine Variable, die die Adresse einer anderen Variablen speichert. Ein Zeiger kann auch verwendet werden, um auf eine andere Zeigerfunktion zu verweisen. Ein Zeiger kann inkrementiert/dekrementiert werden, d. h. auf den nächsten/vorherigen Speicherplatz zeigen. Der Zweck des Zeigers besteht darin, Speicherplatz zu sparen und eine schnellere Ausführungszeit zu erreichen.

Wie man Zeiger in C verwendet

Wenn wir eine Variable v vom Typ int deklarieren, speichert v tatsächlich einen Wert.

v ist jetzt gleich Null.

Allerdings hat jede Variable neben dem Wert auch ihre Adresse (oder einfach gesagt, wo sie sich im Speicher befindet). Die Adresse kann abgerufen werden, indem ein kaufmännisches Und (&) vor den Variablennamen gesetzt wird.

Wenn Sie die Adresse einer Variablen auf dem Bildschirm ausgeben, sieht sie wie eine völlig zufällige Zahl aus (außerdem kann sie von Lauf zu Lauf unterschiedlich sein).

Versuchen wir dies in der Praxis mit dem Zeiger im C-Beispiel

Die Ausgabe dieses Programms ist -480613588.

Was ist nun ein Zeiger? Anstatt einen Wert zu speichern, speichert ein Zeiger die Adresse einer Variablen.

Zeigervariable

Int *y =&v;

VARIABLEPOINTERA Wert gespeichert in einem benannten Speicher-/SpeicheradresseEine Variable das auf zeigt die Speicher-/Speicheradresse eines anderen variable

Einen Zeiger deklarieren

Wie Variablen müssen Zeiger in der C-Programmierung deklariert werden, bevor sie in Ihrem Programm verwendet werden können. Pointer können beliebig benannt werden, solange sie den Benennungsregeln von C gehorchen. Eine Pointer-Deklaration hat folgende Form.

data_type * pointer_variable_name;

Hier,

• Datentyp ist der Basistyp des Zeigers der Variablentypen von C und gibt den Typ der Variablen an, auf die der Zeiger zeigt.
• Das Sternchen (*:dasselbe Sternchen, das für die Multiplikation verwendet wird), das ein Indirektionsoperator ist, deklariert einen Zeiger.

Sehen wir uns einige gültige Zeigerdeklarationen in diesem C-Zeiger-Tutorial an:

int    *ptr_thing;            /* pointer to an integer */ 
int *ptr1,thing;/* ptr1 is a pointer to type integer and thing is an integer variable */
double    *ptr2;    /* pointer to a double */
float    *ptr3;      /* pointer to a float */
char    *ch1 ;       /* pointer to a character */
float  *ptr, variable;/*ptr is a pointer to type float and variable is an ordinary float variable */

Einen Zeiger initialisieren

Nachdem wir einen Zeiger deklariert haben, initialisieren wir ihn wie Standardvariablen mit einer Variablenadresse. Wenn Zeiger in der C-Programmierung nicht uninitialisiert und im Programm verwendet werden, sind die Ergebnisse unvorhersehbar und möglicherweise katastrophal.

Um die Adresse einer Variablen zu erhalten, verwenden wir den kaufmännischen Und-Operator (&), der vor dem Namen einer Variablen steht, deren Adresse wir benötigen. Die Zeigerinitialisierung erfolgt mit der folgenden Syntax.

Zeigersyntax

 pointer = &variable;

Ein einfaches Programm zur Zeigerdarstellung ist unten angegeben:

#include <stdio.h>
int main()
{
   int a=10;    //variable declaration
   int *p;      //pointer variable declaration
   p=&a;        //store address of variable a in pointer p
   printf("Address stored in a variable p is:%x\n",p);  //accessing the address
   printf("Value stored in a variable p is:%d\n",*p);   //accessing the value
   return 0;
}

Ausgabe:

Address stored in a variable p is:60ff08
Value stored in a variable p is:10

Operator Bedeutung *Erfüllt 2 Zwecke

1. Deklaration eines Zeigers
2. Gibt den Wert der referenzierten Variable zurück

&Dient nur einem Zweck

• Gibt die Adresse einer Variablen zurück

Zeigertypen in C

Im Folgenden sind die verschiedenen Zeigertypen in C aufgeführt :

Null-Zeiger

Wir können einen Nullzeiger erstellen, indem wir während der Zeigerdeklaration einen Nullwert zuweisen. Diese Methode ist nützlich, wenn Sie dem Zeiger keine Adresse zugewiesen haben. Ein Nullzeiger enthält immer den Wert 0.

Das folgende Programm veranschaulicht die Verwendung eines Nullzeigers:

#include <stdio.h>
int main()
{
	int *p = NULL; 	//null pointer
	printf(“The value inside variable p is:\n%x”,p);
	return 0;
}

Ausgabe:

The value inside variable p is:
0

Void-Zeiger

In der C-Programmierung wird ein Void-Zeiger auch als generischer Zeiger bezeichnet. Es hat keinen Standarddatentyp. Ein void-Zeiger wird mit dem Schlüsselwort void erstellt. Es kann verwendet werden, um eine Adresse einer beliebigen Variablen zu speichern.

Das folgende Programm veranschaulicht die Verwendung eines void-Zeigers:

#include <stdio.h>
int main()
{
void *p = NULL; 	//void pointer
printf("The size of pointer is:%d\n",sizeof(p));
return 0;
}

Ausgabe:

The size of pointer is:4

Wildzeiger

Ein Zeiger wird als wilder Zeiger bezeichnet, wenn er auf nichts initialisiert wird. Diese Arten von C-Zeigern sind nicht effizient, da sie auf einen unbekannten Speicherort verweisen können, der Probleme in unserem Programm verursachen und zum Absturz des Programms führen kann. Man sollte immer vorsichtig sein, wenn man mit wilden Zeigern arbeitet.

Das folgende Programm veranschaulicht die Verwendung von wilden Zeigern:

#include <stdio.h>
int main()
{
int *p; 	//wild pointer
printf("\n%d",*p);
return 0;
}

Ausgabe:

timeout: the monitored command dumped core
sh: line 1: 95298 Segmentation fault      timeout 10s main

Andere Arten von Zeigern in 'c' sind wie folgt:

• Hängender Zeiger
• Komplexer Zeiger
• Nahe-Zeiger
• Fernzeiger
• Großer Zeiger

Direkte und indirekte Zugriffszeiger

In C gibt es zwei äquivalente Möglichkeiten, auf Variableninhalte zuzugreifen und diese zu manipulieren

• Direkter Zugriff:Wir verwenden direkt den Variablennamen
• Indirekter Zugriff:Wir verwenden einen Zeiger auf die Variable

Lassen Sie uns dies mit Hilfe des Programms unten verstehen

#include <stdio.h>
/* Declare and initialize an int variable */
int var = 1;
/* Declare a pointer to int */
int *ptr;
int main( void )
{
/* Initialize ptr to point to var */
ptr = &var;
/* Access var directly and indirectly */
printf("\nDirect access, var = %d", var);
printf("\nIndirect access, var = %d", *ptr);
/* Display the address of var two ways */
printf("\n\nThe address of var = %d", &var);
printf("\nThe address of var = %d\n", ptr);
/*change the content of var through the pointer*/
*ptr=48;
printf("\nIndirect access, var = %d", *ptr);
return 0;}

Nach dem fehlerfreien Kompilieren des Programms lautet das Ergebnis:

Direct access, var = 1
Indirect access, var = 1

The address of var = 4202496
The address of var = 4202496

Indirect access, var = 48

Zeiger-Arithmetik in C

Die Zeigeroperationen sind in der folgenden Abbildung zusammengefasst

Vorrangiger Betrieb (Vorrang)

Bei der Arbeit mit C-Zeigern müssen wir folgende Prioritätsregeln beachten:

• Die Operatoren * und &haben die gleiche Priorität wie die unären Operatoren (die Negation!, die Inkrementierung++, Dekrement–).
• Im selben Ausdruck werden die unären Operatoren *, &,!, ++, – von rechts nach links ausgewertet.

Wenn ein P-Zeiger auf eine X-Variable zeigt, dann kann *P überall dort verwendet werden, wo X geschrieben werden kann.

Die folgenden Ausdrücke sind äquivalent:

int X =10

int *P =&Y;

Für den obigen Code sind die folgenden Ausdrücke wahr

AusdruckÄquivalenter AusdruckY=*P+1

*P=*P+10

*P+=2

++*P

(*P)++

Y=X+1

X=X+10

X+=2

++X

X++

Im letzteren Fall werden Klammern benötigt:Da die unären Operatoren * und ++ von rechts nach links ausgewertet werden, würde ohne die Klammern der Zeiger P inkrementiert, nicht das Objekt, auf das P zeigt.

Die folgende Tabelle zeigt die arithmetischen und grundlegenden Operationen, die beim Umgang mit C-Zeigern verwendet werden können

Betrieb Erklärung Zuweisungint *P1,*P2
P1=P2;
P1 und P2 zeigen auf dieselbe ganzzahlige VariableIncrementation und DecrementationInt *P1;
P1++;P1–;Hinzufügen eines Offsets (Konstante)Damit kann der Zeiger N Elemente in einer Tabelle verschieben.
Der Zeiger wird um das N-fache der Anzahl der Byte(s) des Variablentyps erhöht oder verringert.
P1+5;

C-Zeiger &Arrays mit Beispielen

Traditionell greifen wir über den Index auf die Array-Elemente zu, aber diese Methode kann durch die Verwendung von Zeigern eliminiert werden. Zeiger erleichtern den Zugriff auf jedes Array-Element.

#include <stdio.h>
int main()
{
    int a[5]={1,2,3,4,5};   //array initialization
    int *p;     //pointer declaration
               /*the ptr points to the first element of the array*/

    p=a; /*We can also type simply ptr==&a[0] */
    
    printf("Printing the array elements using pointer\n");
    for(int i=0;i<5;i++)    //loop for traversing array elements
    {
        	printf("\n%x",*p);  //printing array elements
        	p++;    //incrementing to the next element, you can also write p=p+1
    }
    return 0;
}

Ausgabe:

1
2
3
4
5

Das Addieren einer bestimmten Zahl zu einem Zeiger verschiebt die Zeigerposition auf den Wert, der durch eine Additionsoperation erhalten wird. Angenommen, p ist ein Zeiger, der derzeit auf den Speicherplatz 0 zeigt, wenn wir die folgende Additionsoperation ausführen, p+1, dann wird sie auf diese Weise ausgeführt:

Da p nach dem Hinzufügen von 1 derzeit auf die Stelle 0 zeigt, wird der Wert 1, und daher zeigt der Zeiger auf die Speicherstelle 1.

C-Zeiger und Strings mit Beispielen

Ein String ist ein Array von Char-Objekten, das mit einem Nullzeichen „\ 0“ endet. Wir können Strings mit Zeigern manipulieren. Dieser Zeiger im C-Beispiel erklärt diesen Abschnitt

#include <stdio.h>
#include <string.h>
int main()
{
char str[]="Hello Guru99!";
char *p;
p=str;
printf("First character is:%c\n",*p);
p =p+1;
printf("Next character is:%c\n",*p);
printf("Printing all the characters in a string\n");
p=str;  //reset the pointer
for(int i=0;i<strlen(str);i++)
{
printf("%c\n",*p);
p++;
}
return 0;
}

Ausgabe:

First character is:H
Next character is:e
Printing all the characters in a string
H
e
l
l
o

G
u
r
u
9
9
!

Eine andere Möglichkeit, mit Strings umzugehen, ist mit einem Array von Zeigern wie im folgenden Programm:

#include <stdio.h>
int main(){
char *materials[ ] = {  "iron",  "copper",  "gold"};
printf("Please remember these materials :\n");
int i ;
for (i = 0; i < 3; i++) {
  printf("%s\n", materials[ i ]);}
  return 0;}

Ausgabe:

Please remember these materials:
iron
copper
gold

Vorteile von Zeigern in C

• Zeiger sind nützlich, um auf Speicherorte zuzugreifen.
• Zeiger bieten eine effiziente Möglichkeit, auf die Elemente einer Array-Struktur zuzugreifen.
• Zeiger werden sowohl für die dynamische Speicherzuweisung als auch für die Freigabe verwendet.
• Zeiger werden verwendet, um komplexe Datenstrukturen wie verkettete Listen, Diagramme, Bäume usw. zu bilden

Nachteile von Zeigern in C

• Zeiger sind etwas kompliziert zu verstehen.
• Zeiger können zu verschiedenen Fehlern wie Segmentierungsfehlern führen oder auf einen Speicherplatz zugreifen, der gar nicht benötigt wird.
• Wenn einem Zeiger ein falscher Wert bereitgestellt wird, kann dies zu Speicherbeschädigungen führen.
• Zeiger sind auch für Speicherlecks verantwortlich.
• Zeiger sind vergleichsweise langsamer als die der Variablen.
• Programmierer finden es sehr schwierig, mit den Zeigern zu arbeiten; Daher liegt es in der Verantwortung des Programmierers, einen Zeiger sorgfältig zu manipulieren.

Zusammenfassung:

• Ein Zeiger ist nichts anderes als ein Speicherort, an dem Daten gespeichert werden.
• Ein Zeiger wird verwendet, um auf die Speicherstelle zuzugreifen.
• Es gibt verschiedene Arten von Zeigern, wie z. B. Nullzeiger, Wild-Zeiger, Leerzeiger und andere Arten von Zeigern.
• Zeiger können mit Arrays und Strings verwendet werden, um effizienter auf Elemente zuzugreifen.
• Wir können Funktionszeiger erstellen, um eine Funktion dynamisch aufzurufen.
• Arithmetische Operationen können mit einem Zeiger ausgeführt werden, was als Zeigerarithmetik bekannt ist.
• Zeiger können auch auf Funktionen zeigen, was es einfach macht, verschiedene Funktionen aufzurufen, wenn ein Array von Zeigern definiert wird.
• Wenn Sie mit unterschiedlichen variablen Datentypen umgehen möchten, können Sie einen typisierten void-Zeiger verwenden.

Funktionen in der C-Programmierung mit Beispielen:Rekursiv &Inline Funktionszeiger in der C-Programmierung mit Beispielen