In diesem Artikel fasse ich die Dimensionen von Zeigern in vier chinesischen Schriftzeichen zusammen: "Zwei Selbste und drei Andere"! Es liest sich überhaupt nicht flüssig und reimt sich nicht, was ist das bloß? Dieses "Zwei Selbste und drei Andere", ausgeschrieben, ist: Eigenadresse, Eigenwert, Fremdwert, Fremdadresse und Fremdtyp.

Ich denke, wir können Zeiger anhand dieser 5 Dimensionen besprechen. Aber bevor ich das tue, habe ich ein Programm geschrieben, das alle "Zwei Selbste und drei Andere"-Dimensionen von Zeigern enthält, und dann werde ich die Bedeutung jeder Dimension einzeln erklären. Schauen wir, ob es so ist.

In den meisten Szenarien, in denen Zeiger verwendet werden, sollten diese 5 Dimensionen ausreichen, um beim Verständnis zu helfen. In einigen speziellen Szenarien der Verwendung von Zeigern hilft die 5-Dimensionen-Methode jedoch möglicherweise nicht weiter.

Warnung: Langer Artikel voraus. Wenn Sie ungeduldig werden, können Sie diesen Artikel mit einem Lesezeichen versehen und später weiterlesen, wenn Sie Zeit haben.

1. Programmcode

1.1. Code

Das Ausführungsergebnis ist wie folgt:

In meinen Artikeln verwende ich, wenn ich über Dinge spreche, die ich verstehe, gern sehr einfache Programme zur Veranschaulichung. Diejenigen Experten, die meinen, ein Punkt müsse mit einem unergründlichen Programm veranschaulicht werden, oder die auf Low-Level-Programme herabsehen, mögen mich bitte ignorieren ^_^.

2.2. int-Variable para

Im Programm:

int para = 1;
printf("变量para自己的地址是:  0X%x\n", &para);
printf("变量para自己的值是:  0X%x\n", para);

Das Programm definiert die Variable para, die ihren eigenen Datenwert und ihre eigene Speicheradresse hat; das ist leicht zu verstehen. Aus der Ausgabe geht hervor, dass der eigene Datenwert der Variable para hexadezimal "0X1" ist und ihre Adresse hexadezimal "0X22feb4". Mit anderen Worten: Im Speicher enthält der Speicherplatz ab der Adresse "0X22feb4" 4 Bytes, in denen ein Datenwert "0X1" gespeichert ist. Auf meinem Rechner belegt eine int-Variable 4 Bytes; auf Ihrem Rechner kann das anders sein.

Jeder versteht die int-Variable para. Als Nächstes zeichne ich ein schematisches Diagramm, um zu zeigen, wie die Variable para im Speicher abgelegt ist, wie folgt:

Als Nächstes sprechen wir über das Konzept von "Zwei Selbste und drei Fremde".

2. Zwei Selbste und drei Fremde

"Zwei Selbste und drei Fremde", ausgeschrieben, lautet: Selbstadresse, Selbstwert, Fremdwert, Fremdadresse und Fremdtyp.

2.1. Selbstadresse

2.1.1 Der Begriff "Selbstadresse"

"Selbstadresse" ist die Kurzform für "die eigene Adresse". Als Variable benötigt der Zeiger pInt, genau wie die int-Variable para, ebenfalls einen Speicherplatz im Speicher, und dieser Speicherplatz hat auch eine Startadresse; das heißt, die Zeigervariable pInt hat ebenfalls ihre eigene Adresse. Wie oben erwähnt, ist die Adresse der Variable para "0X22feb4". Also, was ist die Adresse der Zeigervariable pInt?

2.1.2 Ermitteln der „Selbstadresse“

Wir haben alle gelernt, dass „&“ ein Adressoperator ist. Im Programm:

printf("指针变量pInt自己的地址是:  0X%x\n", &pInt);

Sie ermittelt die Adresse der Zeigervariable pInt durch „&“. Aus der Ausgabe geht hervor, dass die Adresse der Zeigervariable pInt „0X22feb8“ ist. Auf meinem Rechner belegt die Zeigervariable pInt ebenfalls 4 Bytes, die Zeigervariable pInt ist also in dem 4-Byte-Bereich gespeichert, der bei der Adresse „0X22feb8“ beginnt.

2.1.3 Codeschreibweise für die „Selbstadresse“

Im Code ist eine übliche Schreibweise für die „Selbstadresse“ der Zeigervariable pInt:

&pInt;

Jetzt verfeinern wir dieses schematische Diagramm, indem wir die „Selbstadresse“ der Zeigervariable pInt hinzufügen, um zu zeigen, wie die Zeigervariable pInt im Speicher abgelegt ist.

Das ist alles, was die „Selbstadresse“ ist. Sie sehen, nichts besonders Schwieriges, oder?

2.2 Der Selbstwert

2.2.1 Das Konzept des „Selbstwerts“

„Selbstwert“ ist die Kurzform für „der eigene Datenwert“. Als Variable hat der Zeiger pInt, genau wie die Variable para, ebenfalls seinen eigenen Datenwert.

2.2.2 Ermitteln des „Selbstwerts“

Wie oben erwähnt, ist der eigene Datenwert der Variable para „1“. Was ist dann der eigene Datenwert der Zeigervariable pInt? Im Programm:

pInt = ¶
printf("指针变量pInt自己的值是:  0X%x\n", pInt);

Mithilfe des Operators "&" habe ich den Adresswert der Variable para der Zeigervariable pInt zugewiesen und printf verwendet, um den Datenwert der Zeigervariable pInt auszugeben. Aus der Ausgabe geht hervor, dass der eigene Datenwert der Zeigervariable pInt "0X22feb4" ist. Beachten wir außerdem, dass die Adresse der Variable para ebenfalls "0X22feb4" ist, also,

pInt = ¶

Der Kern dieser Anweisung besteht darin, der Zeigervariable pInt als Selbstwert die Adresse der Variable para zu geben und dadurch die Zeigervariable pInt und die Variable para miteinander zu verbinden.

Wie unter "Selbstadresse" erwähnt, wird der Datenwert von Pointer pInt in den 4 Bytes Speicher ab der Adresse "0X22feb8" gespeichert. Das heißt, die 4 Bytes Speicher ab der Adresse "0X22feb8" werden verwendet, um einen Datenwert "0X22feb4" zu speichern.

2.2.3 Codeschreibweise für den "Selbstwert"

Übliche Darstellungen im Code für den "Selbstwert" der Zeigervariable pInt sind:

pInt;

Es gibt auch diese Codeschreibweise:

pInt + N;
pInt - N;

Diese Notation bedeutet, eine Zahl N zum "Selbstwert" von pInt zu addieren oder eine Zahl N davon zu subtrahieren; dies wird erwähnt, wenn die Eigenschaft "other-type" behandelt wird. Es gibt auch diese Notation:

pIntA - pIntB;

Diese Notation zeigt an, dass zwei Zeigervariablen mit ihren "Selbstwerten" eine Subtraktion durchführen.

2.2.4 Schematische Darstellung

Nun fahren wir fort und verfeinern die obige schematische Darstellung, indem wir den Selbstwert der Zeigervariable pInt hinzufügen.

Allgemein gesprochen ist für die Zeigervariable pInt der "Selbstwert" ihr eigener Datenwert; für andere Variablen vom Typ int ist er ihre Adresse.

2.3 Andere Adresse

2.3.1 Das Konzept der "Fremdadresse"

Das Konzept der "Fremdadresse" bedeutet "Adresse eines anderen". Tatsächlich wurde das Konzept der "Fremdadresse" bereits erwähnt, als oben von "Eigenwert" die Rede war, wenn auch nicht sehr offensichtlich.

2.3.2 Ermitteln der "Fremdadresse"

Die Integer-Variable para ist in den 4 Bytes gespeichert, die bei der Speicheradresse "0X22feb4" beginnen. Im Programm habe ich

pInt = ¶

um die Adresse der Variable para an die Zeigervariable pInt zu übergeben und damit die Zeigervariable pInt und die Variable para miteinander zu verbinden. Grundlegender gesagt weist es dem "Eigenwert" der Zeigervariable pInt "die Adresse eines anderen" zu. Dabei bezieht sich das "andere" in "Adresse eines anderen" auf die Variable para, und die "Adresse" in "Adresse eines anderen" bezieht sich auf die Adresse der Variable para. Beachte: "Fremdadresse" und "Eigenwert" sind im Datenwert identisch. Hast du also eine Einsicht gewonnen?

Viele Lehrbücher sagen: "Ein Zeiger ist eine Adressvariable, die die Adresse einer anderen Variable speichert". Um es unverblümt zu sagen: Sie sagen damit, dass der Datenwert der Dimension "Fremdadresse" gleich dem Datenwert der Dimension "Eigenwert" ist; die Lehrbücher drücken es nur nicht so klar aus.

2.3.3 Schematische Darstellung

Verfeinern wir diese schematische Darstellung noch einmal, wobei wir diesmal das Konzept der "Fremdadresse" hinzufügen.

2.4 Fremdwert

2.4.1 Das Konzept des "Fremdwerts"

"Fremdwert" bedeutet "Datenwert eines anderen".

2.4.2 Ermitteln des "Fremdwerts"

Im Programm habe ich

pInt = ¶

um die Adresse der Variable para dem "Selbstwert" der Zeigervariable pInt zuzuweisen und so die Zeigervariable pInt und die Variable para miteinander zu verbinden. Zu diesem Zeitpunkt bezieht sich das "andere" in "Datenwert eines anderen" auf die Variable para, und der "Datenwert" in "Datenwert eines anderen" bezieht sich auf den Datenwert "1" der Variable para. Im Programm habe ich

printf("指针变量pInt的他值是:  0X%x\n", *pInt);

: Und das hier? Es ist tatsächlich *(pInt + 1).

2.4.3 Code-Syntax für "anderen Wert"

Diese Codemuster, die man oft im Code sieht, wie das Muster *pInt, was bedeuten sie? Tatsächlich berechnen sie den "anderen Wert" der Zeigervariable pInt!

Was ist mit diesen Mustern: *(pInt + 1), *pInt + 1, pInt

*(pInt + 1): Wenn man pInt + 1 als einen anderen Zeiger betrachtet, zum Beispiel,

int *pTemp = pInt + 1；

dann berechnet *(pInt + 1) im Wesentlichen den "anderen Wert" der Zeigervariable pTemp;

*pInt + 1: Dies addiert 1 zum "anderen Wert" von pInt;

pInt

2.4.4 Schematische Darstellung

Verbessern Sie weiter das obige schematische Diagramm, indem Sie diesmal das Konzept des "anderen Werts" hinzufügen:

2.5 Anderer Typ

2.5.1 Das Konzept des "anderen Typs"

"Anderer Typ" ist die Kurzform für "der Typ des Anderen". Im Programm sehen wir, dass beim Deklarieren der Zeigervariable pInt Folgendes geschrieben wird:

int *pInt = NULL;

Das "int" vor der Zeigervariable pInt bedeutet nicht, dass pInts "eigener Wert" ein Datenwert vom Typ int ist; vielmehr bedeutet es, dass pInts "anderer Wert" ein Datenwert vom Typ int ist. Hier ist pInts "anderer Wert" der Datenwert "0X1" der Variable para, daher zeigt das "int" vor pInt an, dass der Datenwert "0X1" vom Typ "int" ist.

Kurz gesagt: Der beim Deklarieren eines Zeigers angegebene Typ wird verwendet, um den "anderen Wert" zu modifizieren, nicht den "eigenen Wert".

Betrachten Sie nun erneut, wie die Variable para deklariert wird:

int para = 1;

Das "int" vor der Variable para bedeutet, dass der Typ von para ein Ganzzahltyp ist. In diesem Fall ist "int" für para ein "Selbsttyp", was "sein eigener Typ" bedeutet. Nur der Typ in einer Zeigerdeklaration ist ein "anderer Typ", der Typ der Entität, auf die gezeigt wird.

Da der "andere Typ" verwendet wird, um den "anderen Wert" zu modifizieren, welche Bedeutung hat es, diesen "anderen Typ" beim Deklarieren eines Zeigers anzugeben? Lesen Sie weiter!

Im Programm der folgende Codeausschnitt:

int arr_int[2] = {1, 2};    
pInt = arr_int;
printf("arr_int第一个元素arr_int[0]的地址是:  0X%x\n", pInt);
printf("arr_int第二个元素arr_int[1]的地址是:  0X%x\n", pInt + 1);

Ich weise der Zeigervariable pInt die Adresse eines Ganzzahl-Arrays arr_int zu. Dann ändert sich pInts "eigene Adresse" nicht, sie bleibt 0X22feb8, aber sein "eigener Wert" ändert sich.

Gerade eben war pInts "eigener Wert" "0X22feb4", die Adresse der Variable para. Jetzt wird er zu "0X22feac", der Adresse des ersten Elements des Arrays arr_int. Das heißt, die "eigene Adresse" von pInt ändert sich nicht, aber sein "eigener Wert" kann geändert werden.

Betrachten wir nun den Unterschied zwischen "pInt" und "pInt + 1". Hier wird mit pInts "eigenem Wert" gerechnet. Aus dem Ausführungsergebnis ist pInts "eigener Wert" zu diesem Zeitpunkt "0X22feac", und der "eigene Wert" von pInt + 1 ist "0X22feb0". Ist Ihnen etwas aufgefallen? Sie unterscheiden sich um genau 4 Bytes, und ein Datenwert vom Typ "int" belegt ebenfalls zufällig 4 Bytes.

Man könnte meinen, dass pInt + 1, da es 1 zum "eigenen Wert" addiert, "0X22feac + 1" = "0X22fead" ergeben sollte. Warum ist das nicht so? Das ist der Trick, den der "andere Typ" der Zeigervariable pInt spielt.

Die Bedeutung von "anderer Typ" ist in einfachen Worten: "Hey Kumpel pInt, dein anderer Wert ist ein Datenwert vom Typ int. Wenn du in Zukunft deinen eigenen Wert +1, +2 oder -1, -2 verwendest, sei nicht so töricht und addiere 1 Byte, 2 Bytes oder subtrahiere 1 Byte, 2 Bytes. Der int-Typ belegt 4 Bytes, also musst du 4 Bytes als eine Einheit nehmen und 1*4 Bytes, 2*4 Bytes addieren oder 1*4 Bytes, 2*4 Bytes subtrahieren, verstanden? Ach, übrigens, N in pInt + N kann positiv oder negativ sein."

Wenn natürlich der Datentyp "int" auf deinem Rechner 8 Bytes belegt, dann addiert pInt + 1 8 Bytes zum "eigenen Wert", pInt + 2 addiert 8 * 2 = 16 Bytes zum "eigenen Wert". Das ist die Idee.

Ich habe ein weiteres Beispiel im Programm gegeben, um diesen "anderen Typ" zu veranschaulichen. Das Programm ist wie folgt:

double *pDouble = NULL;
double arr_double[2] = {1.1, 2.2};
pDouble = arr_double;
printf("arr_double第一个元素arr_double[0]的地址是:  0X%x\n", pDouble);
printf("arr_double第二个元素arr_double[1]的地址是:  0X%x\n", pDouble + 1);

Diesmal wird eine Zeigervariable pDouble deklariert. Ihr "anderer Typ" ist "double", ihr "eigener Wert" ist die Adresse des Arrays arr_double, und ihr "anderer Wert" ist der Datenwert "1.1" des Elements arr_double

3. Zusammenfassung

Es ist Zeit zusammenzufassen.

Ich deklariere eine Zeigervariable:

type *pType = NULL;

pType hat 5 Dimensionen, nämlich:

pType = (eigene Adresse, eigener Wert, andere Adresse, anderer Wert, anderer Typ);

3.1 Eigenadresse: d.h. "die eigene Adresse"

Als Variable hat die Zeigervariable pType auch ihre eigene Adresse. Die übliche Codesyntax ist "&pType".

Die eigene Adresse wird in gewöhnlichen Programmen nicht häufig verwendet. Wenn sie verwendet wird, geht es um "Zeiger auf Zeiger", was ein anderes Thema ist und in diesem Artikel nicht behandelt wird;

3.2 Eigenwert: d. h. "der eigene Datenwert"

Als Variable hat die Zeigervariable pType ebenfalls ihren eigenen Datenwert. Die Codesyntax lautet "pType".

Sie können auch Additionen und Subtraktionen mit dem Eigenwert durchführen. Häufige Codesyntax umfasst "pType + N", "pType - N", "pType2 - pType1" usw.

3.3 Fremdadresse: d. h. "die Adresse eines anderen"

Der Eigenwert der Zeigervariable pType stellt neben ihrem eigenen Datenwert auch die Adresse einer an pType gebundenen Variable vom Typ "type" dar. Im Allgemeinen stimmen der "Eigenwert" und die "Fremdadresse" der Zeigervariable pType im Datenwert überein.

Eine übliche Möglichkeit, eine Variable vom Typ "type" an pType zu binden, ist: pType = &variable;

3.4 Fremdwert: d. h. "der Datenwert eines anderen"

Sobald eine Variable vom Typ "type" an pType gebunden ist, kann die Zeigervariable pType den Wert der Variable vom Typ "type", d. h. den "Fremdwert", über eine bestimmte Codesyntax erhalten. Häufige Codesyntax umfasst "*pType", "pType->" usw.

Und diese Code-Muster: "*(pType + N)", "*(pType - N)", "pType[N]" erhalten ebenfalls den "Fremdwert", aber sie bedürfen einer besonderen Erklärung:

Sie können pType + N betrachten als:

type *pTemp = pType + N;

"*(pType + N)" berechnet tatsächlich den "Fremdwert" der Zeigervariable pTemp.

Dann ist "*(pType - N)" für Sie leicht zu verstehen;

"pType[N]" ist eigentlich "*(pType + N)". Merken Sie es sich einfach.

3.5 Anderer Typ: d. h. "der Typ eines anderen"

Wenn die Zeigervariable pType deklariert wird, wird das vorangehende "type" nicht verwendet, um den "eigenen Wert" von pType zu ändern, sondern um den "anderen Wert" zu ändern. Das heißt, "type" bedeutet nicht, dass der "eigene Wert" von pType ein Datenwert vom Typ "type" ist, sondern dass der "andere Wert" von pType ein Datenwert vom Typ "type" ist.

Die Rolle des "anderen Typs" im Code besteht hauptsächlich darin, dass pType beim Berechnen von "pType + N" oder "pType - N" (N * sizeof(type)) Bytes addieren oder subtrahieren muss.

Zeiger machen die Leute immer schwindelig, wahrscheinlich weil einem bei einer oder mehreren dieser 5 Dimensionen schwindelig wird. Wenn man diese 5 Dimensionen gründlich versteht, sind Zeiger nur ein Papiertiger.

4. Übungen erklärt

Nachdem man die 5 Dimensionen abgeschlossen hat, wie könnte man da nicht ein paar praktische Übungen machen? Unten stehen einige Übungen, alle im Zusammenhang mit Zeigern, die Anfänger so schwindelig machen, dass sie aufgeben. Ich verwende diese 5 Dimensionen, um diese Probleme zu interpretieren. Mal sehen, ob es etwas einfacher ist!

4.1 Summieren von Array-Elementen

4.1.1 Programm

Das erste Beispiel ist ein sehr verbreitetes Programm: die Summe der Elemente eines Arrays zu finden. Das Programm lautet wie folgt:

Das Programm ist sehr einfach. Es gibt zuerst alle Elemente des Arrays aus und berechnet dann die Summe aller Elemente. Das Ausführungsergebnis ist wie folgt:

4.1.2 Interpretation mit "zwei eigene, drei andere"

4.1.2.1 Ausgabe von Array-Elementen

Beim Ausgeben von Array-Elementen lautet der Code wie folgt:

pArr = arr;
printf("%d ", pArr[index]);

Diese Codezeile entspricht

pArr = arr;
printf("%d ", *( pArr + index));

Hier werden der "eigene Wert" und der "andere Typ" für die Addition verwendet, und der "andere Wert" wird verwendet, um Array-Elemente zu erhalten.

"Eigener Wert": Der Code weist zuerst den Datenwert des Array-Namens arr dem "eigenen Wert" von pArr zu. Und was ist der Datenwert des Array-Namens arr? Es ist die Adresse des Elements arr

;

int *pTemp = pArr + index;

;

"Anderer Typ": der andere Typ von pArr ist "int". Bei pArr + index, wie viele Bytes werden zum eigenen Wert von pArr addiert? Da der andere Typ von pArr int ist, bedeutet pArr + index den eigenen Wert von pArr plus index * sizeof(int) Bytes, richtig!

pArr: kann als pArr + 0 geschrieben werden, das heißt, es werden 0 * 4 = 0 Bytes addiert. Zu diesem Zeitpunkt ist der eigene Wert von pTemp die Adresse von arr

pArr + 1: 1 * 4 = 4 Bytes addieren. Zu diesem Zeitpunkt ist der eigene Wert von pTemp die Adresse von arr

pArr + 2: 2 * 4 = 8 Bytes addieren. Zu diesem Zeitpunkt ist der eigene Wert von pTemp die Adresse von arr

Auf diese Weise durchläuft pArr + index die Adressen aller Elemente des Arrays.

Sie werden feststellen, dass sich der eigene Wert von pTemp ständig ändert; der eigene Wert und die eigene Adresse von pArr bleiben unverändert.

"Anderer Wert": Da pArr + index die Adressen aller Elemente des Arrays durchlaufen kann, kann man mit *(pArr + index), also *pTemp, den anderen Wert von pTemp erhalten und somit die Werte aller Elemente des Arrays durchlaufen!

4.1.2.2 Summieren von Array-Elementen

Der Code zum Summieren von Array-Elementen lautet wie folgt:

sum = sum + *(pArr + index);

Basierend auf meiner gerade durchgeführten Analyse der Ausgabe von Array-Elementen sollte Ihnen allen klar sein, wie pArr in diesem Code funktioniert!

pArr + index verwendet weiterhin den eigenen Wert von pArr für die Addition und erhält den eigenen Wert eines temporären Zeigers pTemp. Dieser eigene Wert von pTemp ist die Adresse jedes Array-Elements;

Verwende dann *(pArr + inedx), also *pTemp, um den anderen Wert des temporären Zeigers pTemp zu erhalten, der der Wert jedes Elements ist.

Addiere schließlich die jeweiligen anderen Werte von pTemp, um die Summe der Array-Elemente zu berechnen.

4.1.2.3 Zusammenfassung

Versuche, gängige Codeausdrücke wie pArr, pArr + index, *(pArr + index), pArr[index], *pArr + index aus der Perspektive von „zwei Eigenes und drei Anderes“ zu verstehen!

4.2 Zeigerarray

Ein Zeigerarray ist etwas, das Zeiger und Arrays kombiniert. Für Anfänger kann es relativ schwierig zu verstehen sein. Zeigerarrays sind ein relativ großes Thema. Für verwandte Konzepte siehe bitte allgemeine C-Lehrbücher. Hier verwenden wir nur das Konzept von „zwei Eigenes und drei Anderes“, um die zeigerbezogenen Konzepte im Programm zu erklären.

4.2.1 Programm

Für Zeigerarrays habe ich ein Beispiel wie folgt gegeben:

Das Ausführungsergebnis ist wie folgt:

4.2.2 Interpretation mit "zwei Eigenen und drei Anderen"

4.2.2.1 Alle Strings ausgeben

Betrachten Sie zunächst die Definition des Zeiger-Arrays:

char *arr[3] = {"abc", "def", "ghi"};

Jedes Element dieses Arrays scheint ein String zu sein, aber im Wesentlichen ist es so:

char *pChar1 = "abc", *pChar2 = "def", *pChar3 = "ghi";
char *arr[3] = {pChar1, pChar2, pChar3};

Jedes Element des Arrays arr ist tatsächlich ein Zeiger, dessen "anderer Typ" "char" ist.

arr

printf("%s ", arr[0]);

Im Wesentlichen:

printf("%s ", pChar1);

Verwenden Sie den eigenen Wert (oder eine andere Adresse) von pChar1, um 'b' und 'c' nacheinander auszugeben, beginnend bei der Adresse des Zeichens 'a'.

pChar2 und pChar3 lassen sich auf dieselbe Weise verstehen.

4.2.2.2 Gib jedes Zeichen der ersten Zeichenkette "abc" aus

Der Code lautet wie folgt:

char *pArr = arr[0];
printf("%c ", *(pArr + index) );

arr zuweisen

pArr + index bedeutet, index * sizeof(char) Bytes zum eigenen Wert von pArr zu addieren und ergibt eine temporäre Zeigervariable pTemp:

char *pTemp = pArr + index;

Der eigene Wert (oder die andere Adresse) dieses Zeigers pTemp wird nacheinander die Adressen der Zeichen 'a', 'b', 'c' sein; das heißt, der andere Wert von pTemp wird ebenfalls nacheinander die Zeichen 'a', 'b', 'c' sein. Auf diese Weise durchläuft der Zeiger pTemp nacheinander jedes Zeichen der Zeichenkette "abc".

4.3 Verkettete Liste

Verkettete Listen verwenden Zeiger am häufigsten. Bei Operationen wie dem Einfügen von Knoten und dem Löschen von Knoten stößt man immer auf Code wie den folgenden:

p2 = p1->next;
p1->next = p3->next;
...... 

Was zum Teufel ist das? So schwindelerregend! Dieser next-Zeiger, jener next-Zeiger, springt hin und her. Verdammt, mein Kopf ist voller Brei. Haha, hier kommt die 5-Dimensionen-Analysemethode für Zeiger! Was verkettete Listen betrifft, sollte ich sie jedoch besser in einem anderen Artikel erklären. Nachdem ich verkettete Listen erklärt habe, komme ich auf diese next-Zeiger zurück. Ich sage dir, die Essenz verketteter Listen ist genau so. Sobald man sie versteht, sind verkettete Listen noch mehr ein Papiertiger als Zeiger.

Autor: Stone Family's Fish

Quelle: https://zhuanlan.zhihu.com/p/27974028