Zeiger in C: Was ist ein Zeiger in der C-Programmierung? Typen

So verwenden Sie Zeiger in C

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 einfacher gesagt, wo sie sich im Speicher befindet). Die Adresse kann abgerufen werden, indem vor dem Variablennamen ein kaufmännisches Und-Zeichen (&) eingefügt 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 Durchlauf zu Durchlauf unterschiedlich sein).

Versuchen wir dies in der Praxis mit einem 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.

Int *y = &v;

Deklarieren eines Zeigers

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

data_type * pointer_variable_name;

Hier

• Datentyp ist der Basistyp des Zeigers der C-Variablentypen 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 */

Initialisieren Sie einen Zeiger

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

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

Zeigersyntax

 pointer = &variable;

Nachfolgend finden Sie ein einfaches Programm zur Zeigerdarstellung:

#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;
}

Ausgang:

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

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

The value inside variable p is:
0

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

The size of pointer is:4

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

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

Direkte und indirekte Zugriffszeiger

In C gibt es zwei gleichwertige Möglichkeiten, auf den Inhalt einer Variable zuzugreifen und ihn zu bearbeiten

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

Lassen Sie uns dies mit Hilfe des folgenden Programms 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 fehlerfreier Kompilierung des Programms ist das Ergebnis:

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

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

Indirect access, var = 48

Zeigerarithmetik in C

Die Zeigeroperationen sind in der folgenden Abbildung zusammengefasst

Vorrangige Operation (Vorrang)

Beim Arbeiten 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 gleichen Ausdruck werden die unären Operatoren *, &,!, ++, – von rechts nach links ausgewertet.

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

Die folgenden Ausdrücke sind gleichwertig:

int X =10
int *P = &Y;
For the above code, below expressions are true

Im letzteren Fall sind Klammern erforderlich: Da die unären Operatoren * und ++ von rechts nach links ausgewertet werden, würde ohne die Klammern der Zeiger P erhöht und 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

C-Zeiger und Arrays mit Beispielen

Traditionell greifen wir über den Index auf die Array-Elemente zu, diese Methode kann jedoch durch die Verwendung von Zeigern vermieden 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;
}

Ausgang:

1
2
3
4
5

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

Da p derzeit nach der Addition von 0 auf den Speicherort 1 zeigt, wird der Wert zu 1 und der Zeiger zeigt daher auf den Speicherort 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 mithilfe von Zeigern manipulieren. Dieser Zeiger im C-Beispiel erläutert 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;
}

Ausgang:

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 zum Verarbeiten von Zeichenfolgen besteht in 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;}

Ausgang:

Please remember these materials:
iron
copper
gold

Nachteile von Zeigern in C

• Zeiger sind etwas komplex zu verstehen.
• Zeiger können zu verschiedenen Fehlern wie Segmentierungsfehlern führen oder auf einen Speicherort zugreifen, der überhaupt nicht benötigt wird.
• Wenn einem Zeiger ein falscher Wert bereitgestellt wird, kann dies zu einer Speicherbeschädigung führen.
• Zeiger sind auch für Speicherverluste verantwortlich.
• Zeiger sind vergleichsweise langsamer als die der Variablen.
• Programmierern fällt es sehr schwer, 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.
• Für den Zugriff auf den Speicherort wird ein Zeiger verwendet.
• Es gibt verschiedene Arten von Zeigern, z. B. einen Nullzeiger, einen Wild-Zeiger, einen Void-Zeiger 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.
• An einem Zeiger können arithmetische Operationen durchgeführt werden. Dies wird als Zeigerarithmetik bezeichnet.
• Zeiger können auch auf Funktionen verweisen, was den Aufruf verschiedener Funktionen erleichtert, wenn ein Array von Zeigern definiert wird.
• Wenn Sie unterschiedliche variable Datentypen verarbeiten möchten, können Sie einen Typumwandlungs-Void-Zeiger verwenden.