C-Programmierung: How to Work Pointer Math in einem Array

Was passiert, wenn Sie einen Zeiger in C-Programmierung erhöhen? Sagen Sie, dass Zeigervariable dave eine Variable bei der Speicheradresse 0x8000 verweist. Wenn ja, sollten Sie diese Aussage:

dave ++ -

Was wäre der Wert des Zeigers dave?

Ihre erste Neigung könnte sein, zu sagen, dass dave um 1 erhöht werden würde, was richtig ist. Aber das Ergebnis der Berechnung nicht 0x8001 sein. Das ist, weil die Adresse in einem Zeiger Variable gespeichert wird um eins erhöht Einheit, nicht um eine Stelle.

Was ist eine Einheit?

Es hängt vom Variablentyp. Wenn Zeiger dave ein char-Pointer ist in der Tat die neue Adresse konnte 0x8001 sein. Aber wenn dave ein int oder ein Schwimmer waren, die neue Adresse wäre die gleiche wie

0x8000 + sizeof (int)

oder

0x8000 + sizeof (float)

Auf den meisten Systemen ist ein int 4 Bytes, also Sie, dass dave 0x8004 würde gleich nach dem Inkrementbetrieb erraten konnte. Aber warum erraten, wenn Sie codieren können?

Arrays und Zeiger Math stellt ein einfaches Programm, etwas, das man ohne Zeiger Code könnte: Füllen Sie ein int-Array mit den Werten 1 bis 10, und zeigt dann das Array und seine Werte. Aber in Arrays und Zeiger Math wird ein Zeiger verwendet, um das Array zu füllen.

ARRAYS UND POINTER MATH

# include int main () {int Zahlen [10] -int x-int * pn-pn = Zahlen- / * Initialisierung Zeiger * // * Fill Array * / for (x = 0-XLT; 10-x ++) {* pn = x + 1-pn ++ -} / * Anzeige Array * / for (x = 0-XLT; 10-x ++) printf ( "Zahlen [% d] =% d n", x + 1, Zahlen [x] -return) (0) -}

Zeile 7 deklariert den Zeiger pn, und Zeile 9 initialisiert. Das hier nicht erforderlich, weil Zahlen ein Array ist, nicht eine einzelne Variable. Zu diesem Zeitpunkt hält der Zeiger die Basisadresse des Arrays. Beachten Sie, dass das Array leer ist.

Die for-Schleife in den Zeilen 12 bis 16 füllt die Zahlen-Array. Das erste Element ist in Zeile 14 die gefüllt peeker Notation für Zeiger pn verwenden. Dann wird bei Zeile 15, wird Zeiger pn eine Einheit erhöht. Er weist nun auf das nächste Element in dem Array, und die Schleife wird wiederholt.

Übung 1: Kopieren Sie den Quellcode von Arrays und Zeiger Math in Ihren Editor. Erstellen und ausführen.

Übung 2: Ändern Sie den Quellcode aus Übung 1, so dass die Adresse jedes Element im Array zusammen mit seinem Wert angezeigt wird.

In der Ausgabe von Übung 2, sollten Sie sehen, dass jede Adresse um 4 Bytes getrennt ist (unter der Annahme, dass die Größe eines int 4 Bytes auf Ihrem Rechner ist). In der Tat, die Adressen wahrscheinlich alle Ende in den hexadezimalen Ziffern 0, 4, 8 und C.

Übung 3: Füllen Sie die Umwandlung von Arrays und Zeiger Math, und dem, was Sie in Übung begann 2, die zweite, die für Schleife die Werte der Array zeigen die peeker Seite der Zeigervariable pn.

Übung 4: Erstellen Sie ein neues Projekt, die mithilfe von Zeigern ähnlich denen, die gezeigt in Arrays und Zeiger Math ein char-Array füllt. Legen Sie die Größe des char-Array bis 27, so dass es 26 Buchstaben halten kann. Füllen Sie das Array mit den Buchstaben 'A' bis 'Z' durch Zeiger-Notation. Zeigen Sie die Ergebnisse durch die Zeigernotation verwendet wird.

Hier ist ein großer Hinweis:

* Pn = x + 'A'-

LÖSUNG FÜR ÜBUNG 4

# include int main () {char Alphabet [27] -int x-char * pa-pa = Alphabet / * Initialisierung Zeiger * // * Fill Array * / for (x = 0-XLT; 26-x ++) {* pa = x + 'A'-pa ++ -} pa = Alphabet - / * Anzeige Array * / for (x = 0-XLT; 26-x ++) {putchar (* pa) -pa ++ -} putchar (' n ') - (0) zurückzukehren -}

Der Quellcode in Lösung zu Übung 4should ziemlich klar sein, jede Aufgabe einen Schritt zu einer Zeit durchgeführt wird. Aber denken Sie daran, dass viele C-Programmierer wie Aussagen zu kombinieren, und solche Kombinationen vorkommen, häufig mit Zeigern.

Übung 5: Kombinieren Sie die beiden Anweisungen in der ersten for-Schleife von Lösung zu Übung nur eine Anweisung 4to sein:

* Pa ++ = x + 'A'-

Stellen Sie sicher, dass Sie es in richtig eingeben. Erstellen und ausführen.

Der Ausgang ist die gleiche. Was das hässliche Chaos tut, ist hier beschrieben:

A'This Teil der Anweisung x + 'ausgeführt, um den Wert der Variablen x der Buchstaben A. Hinzufügen Der Nettoeffekt ist, dass der Code das Alphabet als der Wert von x steigt marschiert auf.

* Pathé Ergebnis von x + 'A' in den Speicherplatz durch Zeiger pa angegeben platziert wird.

++Der Wert der Variablen pa - die Speicheradresse - wird eine Einheit erhöht. Weil die ++ nach der Variablen angezeigt wird, wird der Wert inkrementiert nach der Wert an dieser Adresse gelesen.

Halten Sie die beiden Aussagen trennen noch funktioniert. Aber nicht jeder Programmierer tut das! Viele von ihnen lieben Zeiger mit dem Inkrementoperator zu stapeln. Achten Sie auf it out! Oder, wenn Sie es verstehen, verwenden Sie es.

Übung 6: Fix Ihren Quellcode aus Übung bis 5, so dass die zweite for-Schleife, die verwendet * pa ++ Monster.

Hoffentlich wird die * pa ++ Zeiger-Sache macht Sinn. Wenn nicht, ein Nickerchen machen und dann wieder kommen und untersuchen Head-Implodieren Programm.

HEAD-Implodieren PROGRAMM

# include int main () {char alpha = 'A'-int x-char * pa-pa = Alpha- / * Initialisierung Zeiger * / for (x = 0-XLT; 26-x ++) putchar ((* pa) ++) - putchar ( ' n') - return (0) -}

Der Quellcode aus Listing 19-4 befasst sich mit einer einzigen char-Variable und nicht ein Array. Daher erfordert die Zeiger Initialisierung in Zeile 9 der Präfix. Vergessen Sie nicht, dass!

Linie 12 in diesem Code enthält den Popel (* pa) ++. Es sieht ähnlich aus wie * pa ++, aber es ist auf jeden Fall nicht. Im Gegensatz zu * pa ++, die auf einen Wert lugt und dann den Zeiger erhöht, erhöht der (* pa) ++ Bau ein Wert spähte wird at- der Zeiger unverändert ist.

Übung 7: Bearbeiten, Erstellen und ein neues Programm starten, indem Sie den Quellcode von Head-Implodieren Programm.

Die (* pa) ++ Betrieb arbeitet, dank der runden Klammern. Das Programm holt die durch * pa dargestellte Wert zuerst und dann dieser Wert erhöht wird. Die Zeigervariable, pn, wird nicht durch die Operation beeinflusst wird.

Um Verwirrung zu vermeiden hier zu diesem Thema die verschiedenen kryptischen Zeiger / peeker Notation doodads sind:

Ausdruck	Adresse p	Wert * p
* P ++	Erhöht, nachdem der Wert gelesen	Unverändert
* (P ++)	Erhöht, nachdem der Wert gelesen	Unverändert
(* P) ​​++	Unverändert	Erhöht, nachdem es gelesen hat,
* ++ P	Erhöht, bevor der Wert gelesen	Unverändert
* (++ P)	Erhöht, bevor der Wert gelesen	Unverändert
++* p	Unverändert	Erhöht, bevor es gelesen hat,
++(* P)	Unverändert	Erhöht, bevor es gelesen hat,