3. Zeiger und ++

Zeiger und ++

  • 0

    Hi,

    Ich lese gerade ein Buch ueber C++ und da taucht beim Kapitel Zeiger der "++" Operator auf und da steht beschrieben "Zeiger um Datentyplänge erhöhen". Was bedeutet das genau. Wie kann man das am folgenden Programm sehen was der "++" macht ? 😕 😕

    int i, n = 10;
double *hizei;
double *xzei = new double[n];
hizei = xzei;                      //was passiert hier ??
for(i=1;i <= n; i++) *hizei++ = i; //was macht *hizei++ genau ???
for(i=0;i <  n; i++) cout << " " << *(xzei+i);

    thx

    0
  • ?

    siehe Pointer-Arithmetik. Erhöhung jeweils um die Typbreite.

    0
  • P

    Hi

    der postincerement operator incrementiert den zeiger, d.h der Zeiger zeigt dann nicht mehr auf die Ursprüngliche Addresse sondern auf eine neu die sich datentyplänge von der alten entfernt befindet.Das ist ja auch logisch sonst könntest du ja ein array nicht sicher durchlaufen.
    Also bsp.:

    //----- snip -----------
int i[2]={1,2,3}; //integer in der regel 4 byte auf unices
int *pi; //Zeiger auf integer
pi=i;    //zuweisung der addresse von i an pi
pi++;    //erhöhen der Address um 4 byte. pi zeigt jetz auf die address 
         // von i + 4byte das entspricht i[1]
cout<<*pi<<endl; //dereferenzieren des Wertes an der Addresse auf die pi zeigt
cout<<i[1]<<endl; //ausgeben des Wertes von i[1]. entspricht *pi.
*pi++    //dereferenzieren und incrementieren des Wertes an Addresse auf die ...
cout<<i[1]<<endl; //Ausgabe von i[1]. i[1] is jetz um 1 größer

//--- snap ---

    Ich kann nicht so gut erklären aber ich hoffe du weisst was gemeint ist.

    0
  • 0
     

    int var[10];
int *pvar = new int[10]

for(int i=0;i<10;i++)var[i] = i;
for(int j=0;j<10;j++)*pvar++ = i

    Kann man das so verstehen das die beiden Schleifen beide das gleiche machen nur die eine auf nomalen Variablen und die andere auf Zeigern ? Und wie genau ist das zu verstehen mit "Das ist ja auch logisch sonst könntest du ja ein array nicht sicher durchlaufen." 😕 😕

    0
  • P

    Original erstellt von 0x0000F:
    **```cpp
    int var[10];
    int *pvar = new int[10]

    for(int i=0;i<10;i++)var[i] = i;
    for(int j=0;j<10;j++)*pvar++ = i

    
  
  
Kann man das so verstehen das die beiden Schleifen beide das gleiche machen nur die eine auf nomalen Variablen und die andere auf Zeigern ? Und wie genau ist das zu verstehen mit "Das ist ja auch logisch sonst könntest du ja ein array nicht sicher durchlaufen." :confused: :confused:**

    Jep, die machen genau das gleiche. Und übrigens ist foo[bar] definiert als *(foo+bar).

    Zur Zeigererhöhung: Stell dir vor, du hast einen Pointer auf short int (2 Byte).
    Der zeigt jetzt irgendwo im Hauptspeicher hin, z.B. hier:

    FE24|32BD|2C3F
^

    (Die Striche sind nur zur Unterteilung in 2-Byte-Gruppen)
    Wenn du jetzt den Pointer um 1 erhöhst, geht die Adresse um 2 Bytes weiter:

    FE24|32BD|2C3F
     ^

    Alles klar? 🙂

    0
  • 0

    Jo cool dann hab ich das glaube ich jetzt verstanden 🙂
    Aber eine Frage bleibt mir noch, ich hab immer gedacht man muesste Zeiger immer
    mit dem "&" Operator initalisieren so wie im zweiten Beispiel unten aber wenn ich nun einen Zeiger auf einen Zeiger initalisieren will wieso reicht denn dann "j = i" und wieso muss es nicht heißen "j = &i" 😕

    int *i = new int;
int *j; 
j = i;  

int k;
int *m;
m = &k;
    0
  • M

    Und wo das a[b] == *(a + b) gefallen ist, muss noch erwähnt werden, dass - für Pointer - gilt: a[b] == b[a], das heißt, 3["hallo"] ist legal und funktioniert.

    0
  • P

    ...das heißt, 3["hallo"] ist legal und funktionier

    is ja cool... hab ich ja noch gar nicht gewusst:D...
    das dient aber nicht unbedingt der lesbarkeit oder??

    Aber eine Frage bleibt mir noch, ich hab immer gedacht man muesste Zeiger immer
    mit dem "&" Operator initalisieren so wie im zweiten Beispiel unten aber wenn ich nun einen Zeiger auf einen Zeiger initalisieren will wieso reicht denn dann "j = i" und wieso muss es nicht heißen "j = &i"

    wenn du &i schreibst bekommst du einen zeiger auf ne variable...
    also:

    int  i; //variable
int* p,q; //zeiger
p = &i; //p ist jetz der zeiger auf i
p = i;  //falsch weil du hier die variable in den zeiger kopieren willst
p = &q  //auch falsch weil &q ist jetz ein zeiger auf einen zeiger

    mfg
    Plassy

    [ Dieser Beitrag wurde am 04.07.2003 um 20:39 Uhr von Plassy editiert. ]

    0
  • E

    siehe auch hier:
    http://www.henkessoft.de/arrays_pointer.htm
    http://www.function-pointer.org/

    0
Anmelden zum Antworten