Ändern Sie Zeiger auf ein Array ein bestimmtes Array-Element zu erhalten

Question

Ich verstehe die allgemeine Bedeutung von Zeigern und Referenzen (oder zumindest denke ich, ich), ich auch verstehen, dass, wenn ich neue Ich bin dynamische Zuweisung Speicher.

Meine Frage ist folgende:

Wenn ich cout << &p verwenden, wäre es die „virtuelle Speicherstelle“ von p anzuzeigen. Gibt es eine Möglichkeit, in der ich diese manipulieren kann mit der „virtuellen Speicherplatz?“

Zum Beispiel: Der folgende Code zeigt ein Array von ints.

Wenn ich den Wert von p[1] zeigen wollte, und ich wusste, dass die „virtuelle Speicherstelle“ von p, kann ich irgendwie „&p + 1“ und den Wert von p[1] mit cout << *p erhalten, die nun auf das zweite Element Punkt in der Array?

int *p;
p = new int[3];

p[0] = 13;
p[1] = 54;
p[2] = 42;

Answer 1

Sicher, können Sie den Zeiger manipulieren die verschiedene Elemente in dem Array zuzugreifen, aber Sie müssen den Inhalt des Zeigers manipulieren (dh die Adresse, welche p zeigt auf), anstatt die Adresse des Zeigers selbst .

int *p = new int[3];
p[0] = 13;
p[1] = 54;
p[2] = 42;

cout << *p << ' ' << *(p+1) << ' ' << *(p+2);

Jede Addition (oder Subtraktion) bedeutet, das nachfolgende (prior) Element in der Anordnung. Wenn p verweist auf eine 4-Byte-Variable (zB int auf typische 32-Bit-PCs) an der Adresse 12345 sagen, p + 1 wird auf 12349 zeigen und nicht 12346. Hinweis möchten Sie den Wert ändern was p enthält, bevor dereferencing darauf zuzugreifen, was er zeigt.

Answer 2

Nicht ganz. &p ist die Adresse des Zeigers p . &p+1 wird auf eine Adresse beziehen, die weiter entlang einer int* ist. Was Sie tun möchten, ist

p=p+1; /* or ++p or p++ */

Wenn Sie nun tun

cout << *p;

Sie erhalten wird 54. Der Unterschied ist, p enthält die Adresse des Beginns des Arrays von Ints , während &p ist die Adresse von p . Um ein Element zu bewegen entlang, müssen Sie weiter in die int Array-zu-Punkt , nicht weiter auf Ihrem Stack, das ist, wo p Leben.

Wenn Sie nur &p hatte dann würden Sie müssen folgendes tun:

int **q = &p; /* q now points to p */
*q = *q+1;
cout << *p;

Das wird auch die Ausgabe 54, wenn ich mich nicht täuscht.

Answer 3

Es ist eine Weile (viele Jahre), seit ich mit Zeigern gearbeitet, aber ich weiß, dass wenn p am Anfang des Arrays zeigt (dh p [0]) und Sie erhöhte es (dh p ++), dann wird p jetzt sein zeigt auf p [1].

Ich denke, dass Sie auf den Wert, um de-Referenz p bekommen haben. Sie dereferenzieren einen Zeiger durch einen * vor ihm setzen.

So * p = 33 mit Änderung p [0] bis 33.

Ich bin das Erraten das zweite Element bekommen Sie * verwenden würden (p + 1), so dass die Syntax, die Sie wären bräuchten:

cout << *(p+1)

oder

cout << *(++p)

Answer 4

Ich mag, dies zu tun:

&p[1]

Für mich sieht es sauberere.

Answer 5

Betrachten „Zeigertypen“ in C und C ++ als eine sehr lange, logische Reihe von Zellen zur Festlegung in dem Speicherraum der CPU auf das Bytes überlagert ist, ab Byte 0. Die Breite in Bytes jeder Zelle, abhängig ist, auf dem „Typ“ des Zeigers. Jeder Zeigertyp legt downs eine Reihe mit unterschiedlichen Zellenbreiten. Ein "int *" Zeiger enthält eine Reihe von 4-Byte-Zellen ab, da die Lagerbreite eines int 4 Byte. A "double *" enthält eine 8-Byte-pro-Zellen-Reihe; ein "struct foo *" Zeiger legt, wobei jede Zelle der Breite eines einzelnen "struct foo" eine Zeile nach unten, was auch immer das ist. Die „Adresse“ eines „Dings“ ist die Byte-Offset, beginnend bei 0, der Zelle in der Zeile, die „Sache“ zu halten.
Zeigerarithmetik auf Zellen in der Reihe basiert, nicht Bytes. „*(p+10)“ ist ein Verweis auf die 10. Zelle Vergangenheit „p“, wo die Zellgröße durch die Art der p bestimmt wird. Wenn die Art der „p“ ist, „int“, die Adresse „p + 10“ ist 40 Bytes Vergangenheit p; wenn p ein Zeiger auf eine struct 1000 Bytes lang ist, "p + 10" beträgt 10.000 Bytes Vergangenheit p. (Beachten Sie, dass der Compiler eine optimale Größe für eine Struktur wählen wird, die als größer sein kann, was Sie denken würden, dies zu „padding“ fällig ist und „Ausrichtung“ Die 1000-Byte-Struktur diskutiert könnte nehmen tatsächlich 1024 Bytes pro Zelle. zum Beispiel so, "p + 10" tatsächlich 10.240 Bytes Vergangenheit p wäre.)