Wie versteht man Zeigerarithmetik??

xStrykex

out schrieb:

out schrieb:

Nein, jetzt hast du einen Pointer auf ein char.

char, wie komm ich auf char ich meinte natürlich int.

Dann rate ich dir mal alles durchzulesen und nicht nur einen Teil..

cooky451 schrieb:

Namal schrieb:

Ja das haben die dem Arnold auch eingeredet, als er die ersten 20 mal versucht hat Schauspieler zu werden.

Aber seien wir doch mal ehrlich.. sie hatten recht.

Nö, kein Terminator ohne Arni.

xStrykex schrieb:

out schrieb:

out schrieb:

Nein, jetzt hast du einen Pointer auf ein char.

char, wie komm ich auf char ich meinte natürlich int.

Dann rate ich dir mal alles durchzulesen und nicht nur einen Teil..

Ah so, war noch in der Mitte des Threads.

Bleiben noch die Fragen offen, warum man kein

int *p2 = zahl;
oder
int *p3 = &zahl[0];

benutzen sollte.

SeppJ

Das ist nicht prinzipiell falsch, es ist im gezeigten Programm bloß völlig sinnlos, da der Zeiger nicht benutzt wird. Es gibt ja auch gar keinen Grund, diesen Zeiger jemals zu benutzen, da er schließlich bloß auf den Anfang des Arrays zeigt und man somit ebenso gut auch gleich den Arraybezeichner direkt benutzen könnte.

SeppJ schrieb:

Das ist nicht prinzipiell falsch, es ist im gezeigten Programm bloß völlig sinnlos, da der Zeiger nicht benutzt wird. Es gibt ja auch gar keinen Grund, diesen Zeiger jemals zu benutzen, da er schließlich bloß auf den Anfang des Arrays zeigt und man somit ebenso gut auch gleich den Arraybezeichner direkt benutzen könnte.

Das ist mir schon klar, aber out schrieb ja:

http://www.c-plusplus.net/forum/p2281536#2281536

Selbst wenn der Pointer auf das erste Element des Arrays zeigt, also auf ein int, dann habe ich mit diesem Pointer mithilfe der Zeigerarithmetik dennoch zugriff auf das vollständige Array.
Warum sollte ich den Pointer also auf ein Array zeigen lassen, wozu?
Was ist der Sinn dahinter, wenn das zeigen auf das erste Element genügt.

Belli

SeppJ schrieb:

Es gibt ja auch gar keinen Grund, diesen Zeiger jemals zu benutzen,

Das sehe ich anders. Da nach Zeigerarithmetik gefragt ist, könnte man schön demonstrieren, dass die Adresse beim Inkrementieren um sizeof(int) erhöht wird, während sie bei einem Zeiger auf char um sizeof(char) erhöht wird, usw.

Auch würde ich mal gerne wissen, wie so etwas:

Nein, jetzt hast du einen Pointer auf ein int. Wenn du ein Pointer auf das Array willst, musst du schon
int (*pZahl)[5] = &Zahl;
schreiben.

im Programmcode abgebildet wird?

Im Prinzip zeigt ein Pointer ja nur auf eine Adresse und nicht auf das gesamte Adressfeld des Arrays, insofern zeigt er dann ja doch nur auf das erste Element, einem int.

Insofern reicht
*pZahl = Zahl;
oder
*pZahl = &Zahl[0];

doch völlig.

SeppJ

Das macht alles keinen Sinn. Es geht doch nur darum, dass array und &array[0] etwas ganz anderes bedeuten als &array . Die ersten beiden sind Zeiger auf ein bestimmtes Element (das nullte) des Feldes, das letztere ist ein Zeiger auf das Feld selbst. Das ist ein Riesenunterschied, wie du bei deinen Versuchen festgestellt haben solltest, über diese Zeiger auf die Elemente des Feldes zuzugreifen.

Sone

SeppJ schrieb:

Das macht alles keinen Sinn. Es geht doch nur darum, dass array und &array[0] etwas ganz anderes bedeuten als &array . Die ersten beiden sind Zeiger auf ein bestimmtes Element (das nullte) des Feldes

array ist kein Zeiger.

, das letztere ist ein Zeiger auf das Feld selbst.

&array[0] und &array ist ganz genau dasselbe.
Wo soll da der Unterschied sein?

SeppJ schrieb:

Das macht alles keinen Sinn. Es geht doch nur darum, dass array und &array[0] etwas ganz anderes bedeuten als &array . Die ersten beiden sind Zeiger auf ein bestimmtes Element (das nullte) des Feldes, das letztere ist ein Zeiger auf das Feld selbst. Das ist ein Riesenunterschied, wie du bei deinen Versuchen festgestellt haben solltest, über diese Zeiger auf die Elemente des Feldes zuzugreifen.

Das ist mir schon klar, aber wozu brauche ich einen Zeiger auf das gesamte Feld und wie schon bereits gefragt, wie wird das abgebildet?

Das da:

#include<iostream>

#define MAX 5

int main(){
  char carray[MAX] = {'a', 'b', 'c', 'd', 'e'};

  char (*cp1)[MAX] = &carray;
  char *cp2 = carray;
  char *cp3 = &carray[0];

  for (int i = 0; i < MAX; i++){
    std::cout << "adresse = " << (void*) &(*cp1)[i] << " Wert = " << (*cp1)[i] << std::endl;
    std::cout << "adresse = " << (void*) (cp2+i)<< " Wert = " << *(cp2+i) << std::endl;
    std::cout << "adresse = " << (void*) (cp3+i)<< " Wert = " << *(cp3+i) << std::endl;      
  }  

}

ergibt die Ausgabe:

adresse = 0x28feaf Wert = a
adresse = 0x28feaf Wert = a
adresse = 0x28feaf Wert = a
adresse = 0x28feb0 Wert = b
adresse = 0x28feb0 Wert = b
adresse = 0x28feb0 Wert = b
adresse = 0x28feb1 Wert = c
adresse = 0x28feb1 Wert = c
adresse = 0x28feb1 Wert = c
adresse = 0x28feb2 Wert = d
adresse = 0x28feb2 Wert = d
adresse = 0x28feb2 Wert = d
adresse = 0x28feb3 Wert = e
adresse = 0x28feb3 Wert = e
adresse = 0x28feb3 Wert = e
Drücken Sie eine beliebige Taste . . .

Ein Albtraum!
Ich bin in einer Zeitschleife gefangen!
Und das so kurz vor Weihnachten...

PS:

Natürlich ohne Zeile 16.

Belli

Furble Wurble schrieb:

Ein Albtraum!
Ich bin in einer Zeitschleife gefangen!
Und das so kurz vor Weihnachten...

Belli

Sone schrieb:

&array[0] und &array ist ganz genau dasselbe.
Wo soll da der Unterschied sein?

Das sagt Dir Dein freundlicher Compiler auf diesen Versuch:

int ar[5];
int *ptr = &ar[0];
int *ptr2 = &ar;

Interessant ist übrigens, dass das da:

std::cout << "adresse = " << &(*cp1)[0] << std::endl;
  std::cout << "adresse = " << (cp2)   << std::endl;
  std::cout << "adresse = " << (cp3)  << std::endl;

das gesamte Array ausgibt:

adresse = abcde*
adresse = abcde*
adresse = abcde*

So ganz ohne for Schleife.
Was macht hier cout?

Verwandelt cout alle Elemente des Arrays in einen zusammenhängenden String?

Bashar

Sone schrieb:

&array[0] und &array ist ganz genau dasselbe.
Wo soll da der Unterschied sein?

Das eine ist int*, das andere int (*)[N]. Das hättest du auch selbst wissen können.

Totale Verwirrung schrieb:

Das ist mir schon klar, aber wozu brauche ich einen Zeiger auf das gesamte Feld und wie schon bereits gefragt, wie wird das abgebildet?

Das "braucht" man für mehrdimensionale Arrays, die ja nichts anderes als Arrays mit wiederum Arrays als Elementen sind.

Und abgebildet wird das, wie du schon gemerkt hast, auch bloß als Adresse. Der Unterschied liegt im Typ.

Sone

Belli schrieb:

Sone schrieb:

&array[0] und &array ist ganz genau dasselbe.
Wo soll da der Unterschied sein?

Das sagt Dir Dein freundlicher Compiler auf diesen Versuch:
int ar[5];
int *ptr = &ar[0];
int *ptr2 = &ar;

Die Typen sind natürlich verschieden. :xmas1:
Klar, das eine ist die Adresse eines Feldes, das andere die eines Elementes.
Aber die Adressen sind gleich, das wollte ich damit sagen
Macht wohl doch einen größeren Unterschied als ich dachte.

Belli schrieb:

Sone schrieb:

&array[0] und &array ist ganz genau dasselbe.
Wo soll da der Unterschied sein?

Das sagt Dir Dein freundlicher Compiler auf diesen Versuch:
int ar[5];
int *ptr = &ar[0];
int *ptr2 = &ar;

Deswegem schreibt man anstatt

int *ptr2 = &ar;

ja auch:

int (*ptr2)[5] = &ar;

Die Frage ist allerdings, wozu?

Wozu brauche ich einen Zeiger auf ein "gesamtes" Array,
wenn ich mein Array z.B. an Funktion xy übergeben möchte, dann geht das auch wenn ich nur einen Zeiger, der auf das erste Element des Arrays zeigt, an die Funktion xy übergebe.

Wozu ist das also gut, einen Zeiger auf ein "gesamtes" Array zeigen zu lassen?

EDIT:

Bashar schrieb:

Das "braucht" man für mehrdimensionale Arrays, die ja nichts anderes als Arrays mit wiederum Arrays als Elementen sind.

Also ich brauch's nicht, guckst du hier:

int m[2][4] = { {11, 12, 13, 14}, {21, 22, 23, 24} };

  for (int i = 0; i < 2; i++){
      for (int j = 0; j < 4; j++) {
          std::cout << m[i][j] << ' ';
      }
      std::cout << std::endl;
  }

  std::cout << std:: endl << "Und nun mit einem normal normalen Zeiger auf das\nerste Element eines mehrdimensionalen Arrays" << std::endl;
  int *pm = &m[0][0];

  for (int i = 0; i < 2; i++){
      for (int j = 0; j < 4; j++) {
          std::cout << *(pm+i*4+j) << ' ';
      }
      std::cout << std::endl;
  }

Ausgabe:

11 12 13 14
21 22 23 24

Und nun mit einem normal normalen Zeiger auf das
erste Element eines mehrdimensionalen Arrays
11 12 13 14
21 22 23 24

Sone schrieb:

&array[0] und &array ist ganz genau dasselbe.
Wo soll da der Unterschied sein?

Was redest du den da wieder?
&array[0] ist die Adresse des ersten Element des Arrays.
&array ist die Adresse des Arrays.
Totaler Unterschied. Dass viele Leute denken, es sei dasselbe, überrascht mich nicht, wenn die halbe Welt behauptet,

int ar[10] = {};
int *p = &ar[0];

dass p ein Zeiger auf das Array ar ist. Wenn du schreibst

int i;
int* pi = &i;

sagst du ja auch nicht pi zeigt auf ein Array.

Sone

out schrieb:

Sone schrieb:

&array[0] und &array ist ganz genau dasselbe.
Wo soll da der Unterschied sein?

Was redest du den da wieder?
&array[0] ist die Adresse des ersten Element des Arrays.
&array ist die Adresse des Arrays.

Was redest du den da wieder?
Die Adressen sind gleich.
Nähmen wir Zeiger, dann hätten diese Zeiger verschiedene Typen - das ist der Unterschied den ich aber nicht berücksichtigen wollte.
Die Adressen sind gleich. Nur wie du es ausdrückst, ist der Unterschied.