Warum ein Zeiger + 1 eigentlich 4 addiert

#include<stdio.h>
int main(void){
  int *ptr,a,b;
  a = ptr;
  b = ptr + 1;
  printf("the vale of a,b is %x and %x respectively",a,b);

  int c,d;
  c = 0xff;
  d = c + 1;
  printf("the value of c d are %x and %x respectively",c,d);
  return 0;
}

der Ausgangswert ist

the vale of a,b is 57550c90 and 57550c94 respectively
the value of c d are ff and 100 respectively%  

es stellt sich heraus das ptr + 1 tatsächlich, warum es sich so verhält?

Weil Zeiger so konzipiert sind, dass sie mit Arrays kompatibel sind:

*(pointer + offset)

ist äquivalent zu

pointer[offset]

Zeigerarithmetik funktioniert also nicht in Bezug auf Bytes, sondern in Bezug auf sizeof(pointer base type)-Bytes große Blöcke.

Überlegen Sie, was ein Zeiger ist … es ist eine Speicheradresse. Jedes Byte im Speicher hat eine Adresse. Wenn Sie also eine haben int das sind 4 Bytes und seine Adresse ist 1000, 1001 ist eigentlich das 2. Byte davon int und 1002 ist das dritte Byte und 1003 ist das vierte. Da die Größe eines int von Compiler zu Compiler variieren kann, ist es zwingend erforderlich, dass Sie beim Erhöhen Ihres Zeigers nicht die Adresse eines Mittelpunkts in der erhalten int. Die Aufgabe, basierend auf Ihrem Datentyp herauszufinden, wie viele Bytes zu überspringen sind, wird also für Sie erledigt, und Sie können einfach den Wert verwenden, den Sie erhalten, und sich nicht darum kümmern.

Wie Basile Starynkvitch betont, variiert dieser Betrag je nach dem sizeof Eigenschaft des Datenelements, auf das gezeigt wird. Es ist sehr leicht zu vergessen, dass, obwohl Adressen sequenziell sind, die Zeiger Ihrer Objekte den tatsächlichen Speicherplatz berücksichtigen müssen, der zum Unterbringen dieser Objekte erforderlich ist.

Zeigerarithmetik ist ein heikles Thema. Eine Zeigeraddition bedeutet den Übergang zu einem nächsten Element, auf das gezeigt wird. Die Adresse wird also um den inkrementiert sizeof das spitze Element.

Kurze Antwort

Die Adresse des Pointers wird um inkrementiert sizeof(T) wo T ist der Typ, auf den gezeigt wird. Also für ein intwird der Zeiger um inkrementiert sizeof(int).

Wieso den?

Nun, in erster Linie verlangt es die Norm. Der Grund, warum dieses Verhalten nützlich ist (abgesehen von der Kompatibilität mit C), liegt darin, dass Sie eine Datenstruktur haben, die zusammenhängenden Speicher verwendet, wie ein Array oder eine std::vector, können Sie zum nächsten Element im Array wechseln, indem Sie einfach eins zum Zeiger hinzufügen. Wenn Sie zum n-ten Element im Container wechseln möchten, fügen Sie einfach n hinzu.

Schreiben können firstAddress + 2 ist viel einfacher als firstAddress + (sizeof(T) * 2)und hilft, Fehler zu vermeiden, die durch die Annahme von Entwicklern entstehen sizeof(int) ist 4 (möglicherweise nicht) und schreibt Code wie firstAddress + (4 * 2).

In der Tat, wenn Sie sagen myArray[4]du sagst myArray + 4. Aus diesem Grund beginnen Array-Indizes bei 0; Sie addieren einfach 0, um das erste Element zu erhalten (dh myArray zeigt auf das erste Element des Arrays) und n, um das n-te zu erhalten.

Was ist, wenn ich jeweils ein Byte verschieben möchte?

sizeof(char) ist garantiert ein Byte groß, sodass Sie a verwenden können char* wenn Sie wirklich ein Byte auf einmal verschieben möchten.

Ein Zeiger wird verwendet, um auf ein bestimmtes Speicherbyte zu zeigen, das markiert, wo ein Objekt zugewiesen wurde (technisch gesehen kann er überall hin zeigen, aber so wird er verwendet). Wenn Sie Zeigerarithmetik durchführen, arbeitet sie basierend auf der Größe der Objekte, auf die gezeigt wird. In Ihrem Fall ist es ein Zeiger auf ganze Zahlen, die jeweils eine Größe von 4 Bytes haben.

Betrachten wir einen Zeiger p. Der Ausdruck p+n ist wie (unsigned char *)p + n * sizeof *p (Weil sizeof(unsigned char) == 1). Versuche dies :

#include <stdio.h>
#define N   3

int
main(void)
{
    int i;
    int *p = &i;
    printf("%p\n", (void *)p);
    printf("%p\n", (void *)(p + N));
    printf("%p\n", (void *)((unsigned char *)p + N * sizeof *p));
    return 0;
}