C/C++ Schritt-für-Schritt - Seite 9

 printf("\nAdresse von A ist     : 0x%x", &a);

int *ptr;

pointer   ptr;                 /*  ungültig */
``` Das Problem ist, dass der Compiler wissen muss, auf welche Art von Variable der Zeiger zeigt.  


|  | Deklaration einer Zeiger-Variable  
char *cptr;           /* Zeiger auf Zeichen */  
int *iptr;            /* Zeiger auf int */  
float *fptr;            /* Zeiger auf float */  
struct emp *e;            /* Zeiger auf abstrahierte Daten emp e */ |


#### Zugriff auf die angegebene Variable:

Hier ist eine spezielle Möglichkeit, die Werte einer Variablen über ihre Adresse anstelle ihres Namens zuzugreifen.



|  | /* 60_addr.c */  
#include   
int main()  
{  
int var1 = 11; /* Variable var1 = 11 */  
int *ptr; /* Variable ptr als Zeiger auf */  
  
ptr = &var; /* Halten Sie die Adresse von var in ptr */  
  
printf("Wert von var1 ist %d", *ptr); /* Zeiger auf die Adresse von var1 */  
return 0;  
} |


|  | ![](/files/4f55092a-e6b6-422d-af47-d517ba51db5b.jpg) |


Wenn die Anweisung printf ("%d", ptr); lautet, zeigt sie den Wert von ptr, was die Adresse von var1 bedeutet, aber die obige Anweisung kann den Inhalt der Adresse anzeigen, die in der Variablen ptr gespeichert war.

Programm zur Demonstration der Verwendung von Address_Of und Pointer_To


|  | /* 61_ptrdemo.c */  
#include   
int main()  
{  
int a = 10, *p; /* Ganzzahl a und Zeiger p */  
p = &a; /* Adresse von a an p zuweisen */  
  
printf("\nWert von A : %d", a); /* Inhalt von a */  
printf("\nAdresse von A : 0x%x", &a); /* Adresse von a */  
printf("\nWert von P : 0x%x", p); /* Inhalt von p */  
printf("\nAdresse von P : 0x%x", &p); /* Adresse von p */  
printf("\nInhalt an der Adresse von a : %d", *p); /* Zeiger auf &a */  
return 0;  
} |


#### 5. Zeigerarithmetik

Alle Variablen können arithmetische Operationen unterstützen, ebenso können wir arithmetische Operationen auf Zeigern durchführen. Die C/C++-Sprache unterstützt 4 arithmetische Operationen auf Zeigern, nämlich.


|  | Operation  
Addition  
Subtraktion  
Inkrementierung  
Dekrementierung | Symbol  
+  
-  
++  
-- |



Hinweis: Die Hauptmerkmale der Zeigerarithmetik sind, dass die obigen Operatoren in Bytes in Bezug auf ihren Variablentyp verwendet werden.


|  | /* 62_ptr.c */  
/* Demonstration der Zeigerarithmetik */  
#include   
int main()  
{  
int a, *p;  
a = 100;  
p = &a;  
(*p)++; /* Inkrementieren Sie den Zeiger auf (Inhalt an Adresse) um 1 */  
printf("%d", *p);  
return 0;  
} |
|  | Ausgabe  
101 |


Demonstration der Zeigerarithmetik, Inkrementieren des Adresswerts


|  | /* 63_ptr.c */  
/* Inkrementieren Sie den Adresswert um 1 */  
#include   
int main()  
{  
int a, *p;  
a = 100;  
p = &a;  
*p++; /* Inkrementieren Sie den Adresswert in p um 1 */  
printf("%d", *p);  
return 0;  
}  |
|  | Ausgabe  
Unerwartete Ausgabe |


Das obige Programm veranschaulicht die arithmetischen Operatoren in Bezug auf sowohl Wert- als auch Adressinkrementierung. p ist eine Zeiger-Variable und a wird mit 100 zugewiesen, ebenso wird p mit der Adresse von a zugewiesen.

Jetzt bewirkt **(*p)++, dass der Inhalt, auf den p** zeigt, 100 inkrementiert wird, was zu 101 führt.

#### 6. Zeiger und Arrays

In der C/C++-Sprache ähneln sich die Datentypen Zeiger und Arrays. Die Array-Elementreferenzen sowie die Zeiger-Variable werden beide verwendet, um die Adresse von Datenelementen im Speicher zu halten.


|  | char name[20];  
Oder  
char *name ;  
  
char months[12][10];  
Oder  
char **months; |


Es gibt eine enge Verbindung zwischen Zeigern und Arrays. Hier ist eine Überprüfung von Arrays.


|  | /* 64_ptrarr.c */  
#include   
int main()  
{  
int i, a[5] = { 56, 43, 78, 98, 12 };  
for( i = 0; i < 5; i++)  
printf("\n%d", a[i]);  
return 0;  
} |


Es besteht die Möglichkeit, Array-Elemente mit Zeigernotationen zuzugreifen.  
Finden Sie die Ausgabe des folgenden Programms.


|  | /* 65_ptrarr.c */  
#include   
int main()  
{  
int i, a[5] = { 56, 43, 78, 98, 12 };  
for( i = 0; i < 5; i++)  
printf("\n%d", *(a+ i) );  
return 0;  
} |


Folgen Sie dem nächsten Programm:


|  | /* 66_ptrarr.c */  
#include   
int main()  
{  
int i, a[ ] = { 56, 43, 78, 98, 12 }, *p;  
p = a;  
for( i = 0; i < 5; i++)  
printf("\n%d", *(p+ i) );  
return 0;  
} |


Hier ist ein einfachster Ansatz, um die Elemente des gegebenen Arrays (Größe nicht erforderlich) auszudrucken.


|  | /* 67_ptrarr.c */  
#include   
int main()  
{  
int i, a[ ] = { 56, 43, 78, 98, 12 }, *p;  
p = a;  
while (*p)           /* oder for(int i = 0; i<5; i++ ) */  
printf("\n%d", *p++);  
return 0;  
} |


#### 7. Zeiger und Strings

Ein String ist eine Sammlung von Zeichen, einschließlich Leerzeichen. Diesmal besprechen wir, wie man Strings mit Zeigern behandelt. Keine weiteren Diskussionen, um Verwirrung zu stiften. Hier ist die einfache Aufgabe, sowohl Zeiger als auch Arrays von Strings zu überprüfen.

Es gibt einen subtilen Unterschied zwischen Strings & Zeigern, folgen Sie dem Programm.


|  | /* 68_ptrstr.c */  
#include   
int main()  
{  
char str1[ ] = "Du würdest gerne C erkunden.";  
char *str2 = "Du würdest gerne C erkunden.";  
puts(str1);  
puts(str2);  
str1++; /* Ungültiger Ausdruck */  
str2++; /* Gültiger Ausdruck */  
puts(str2); /* gibt ou würde gerne aus…… */  
return 0;  
} |


Strings als Funktionsargumente

Eine Zeiger-Variable ist flexibler als Array-Variablen, hier ist das Programm, um einen String mit Zeigernotation zu demonstrieren und anzuzeigen.


|  | /* 69_ptrarr.c */  
#include   
void disp(char *p);  
int main()  
{  
char str[ ] = "Hallo!!..Hallo!!.. Zeiger können es handhaben?";  
disp(str);  
return 0;  
} void disp(char *p)  
{  
while(*p)  
printf("%c", *p++);  
} |


Array von Zeigern auf Strings

Es gibt einen Nachteil, ein Array von Strings zu speichern, dass die Unterarrays, die den String halten, alle die gleiche Länge haben müssen. So dass Platz verschwendet wird, wenn Strings kürzer sind als die Unterarrays.  
Hier ist die Lösung:


|  | /* 70_strings.c */  
#include   
int main()  
{  
char *weeks[7 ] = { "Sonntag", "Montag", "Dienstag", "Mittwoch",  
"Donnerstag", "Freitag", "Samstag" };  
int i;  
for( i = 0; i<7; i++)  
puts(weeks[ i ] );  
return 0;  
} |


Wenn Strings kein Teil eines Arrays sind, platziert C/C++ sie zusammenhängend im Speicher, sodass kein Platz verschwendet wird.  

**/* Ein Beispielprogramm, um ein Array von Zeigern vom Typ ‘int’ zu halten */**


|  | /* 71_ptrarr.c */  
#include   
int main()  
{  
int *arr[4]; /* Array von int-Zeigern */  
int i = 31, j = 5, k = 19, l = 71, m;  
  
arr[0] = &i;  
arr[1] = &j;  
arr[2] = &k;  
arr[3] = &l;  
  
for(m = 0; m <= 3; m++)  
printf("\n%d", *(arr[m]) );  
return 0;  
} |


Ein Blick auf Bibliotheksfunktionen

Wir sind bereits mit den Standard-String-Funktionen vertraut. Sie haben String-Argumente, die mit Zeigernotation angegeben sind,  
Wenn wir mit dem Konzept von Zeigern & Strings klar sind, können wir unsere eigenen String-Funktionen schreiben.  
Hier ist ein Beispielprogramm, um einen String zu kopieren.  
  
**/* Kopiert einen String in einen anderen mit Zeigern */**


|  | /* 72_strcpy1.c */  
#include   
void strcpy1(char * dest, char *src);  
  
int main()  
{  
char *str1 = "Wie kann ich mehr über C/C++ lernen!!!";  
char *str2;  
strcpy1(str2, str1);  
puts(str2);  
return 0;  
} void strcpy1(char * dest, char *src)  
{  
while(*src)  
*dest++ = *src++;  
*dest = '\0';  
} |


#### 8. Glossar


| Adresse | Ein Wert, der auf einen Standort im Speicher zeigt. Ein Zeiger enthält die Adresse oder den Standort eines Wertes, im Gegensatz zu dem Wert selbst. |
| Array | Ein Array ist eine Sammlung von Datenelementen desselben Typs. |
| Zusammenhängend | Eine Speichercharakteristik, die angibt, dass die Werte in aufeinanderfolgenden Standorten entweder im Speicher oder auf der Festplatte gespeichert sind. |
| Funktion | Eine Reihe von Anweisungen, um eine bestimmte Aufgabe auszuführen, die mit anderen Funktionen kombiniert werden kann, um ein Programm zu erstellen. |
| Speicher | Beschreibend für ein Gerät oder Medium, das Daten akzeptieren, sie halten und sie auf Anfrage zu einem späteren Zeitpunkt bereitstellen kann. Synonym für Speicherung. |
| Zeiger | Enthält die Adresse oder den Speicherort eines Wertes, im Gegensatz zu dem Wert selbst. |
| RAM | (Zufälliger Zugriffsspeicher) 1. Ein Speichergerät, das so strukturiert ist, dass die Zeit, die zum Abrufen von Daten benötigt wird, nicht wesentlich von der physischen Lage der Daten beeinflusst wird.  2. Der *primäre Speicherbereich* eines Personalcomputers. |
| String | Ein Array, das in der Lage ist, null oder mehr Zeichen zu speichern. In C wird ein String als Zeichenarray mit dem NULL () Zeichen deklariert, um das Ende des Strings anzugeben. |
| Variable | Ein Name, der mit einem Standort im Speicher verbunden ist, dessen Wert sich während der Programmausführung ändern kann. |