Zeigerarithmetik



  • Hallo, Ich habe ein kleines dilemma und wäre über euro Hilfe sehr erfreut:

    int main(){
    int a[]={20, 30, 40};
    int *p = new int;
    *p = 10;
    int *q = a;
    // Schritt 1
    //a[0]=20, a[1]= 30, a[2]=40, p=2000, *p=10, q=1000, *q=20

    *q = *p
    //Schritt 2
    //Veränderungen: a[0]=10, q=10

    q=p;
    p= &a[1];
    ++p;
    *p= 7;
    //schritt 3
    //Veränderungen: a[2]=7, p=2008, *p=7, q= 2000

    p-=1;
    *q=*p;
    //schritt 4
    //Veränderungen: p=2004, *p=30, *q=30

    *p = *(p+1) * *q;
    //schritt 5
    //Veränderungen: a[1]= 210, p=30, *p=210

    Im letzen 5. Schritt verstehe ich nicht warum p=30 wird. und im 3. Schritt verstehe ich nicht warum zu p= 2000+8 dazugezählt worden sind und nicht 4, da ein integer hat ja 4 bytes.

    Vielen Dank schonmal im voraus.

    MfG,
    Wilky



  • Wilky schrieb:

    Hallo, Ich habe ein kleines dilemma und wäre über euro Hilfe sehr erfreut:

    int mein(){
     int a[]={20, 30, 40};
     int *p = new int;
     *p = 10;
     int *q = a;
    // Schritt 1
    //a[0]=20, a[1]= 30, a[2]=40, p=2000, *p=10, q=1000, *q=20
    
    *q = *p
    //Schritt 2
    //Veränderungen: a[0]=10, q=10 
    
    q=p;
    p= &a[1];
    ++p;
    *p= 7;
    //schritt 3
    //Veränderungen: a[2]=7, p=2008, *p=7, q= 2000
    
    p-=1;
    *q=*p;
    //schritt 4
    //Veränderungen: p=2004, *p=30, *q=30
    
    *p = *(p+1) * *q;
    //schritt 5
    //Veränderungen: a[1]= 210, p=30, *p=210
    

    Im letzen 5. Schritt verstehe ich nicht warum p=30 wird. und im 3. Schritt verstehe ich nicht warum zu p= 2000+8 dazugezählt worden sind und nicht 4, da ein integer hat ja 4 bytes.

    Vielen Dank schonmal im voraus.

    MfG,
    Wilky

    Thx für die Code Tags 😉

    int mein()

    LOL 😃



  • In Zeile 11: *q, nicht q;

    Erste Frage:
    p wird eigentlich gar nicht verändert..

    Zweite Frage:
    Zeile 14: p = 2004
    Zeile 15: p = 2008

    Für p = 2000 wäre &a[0] oder a;



  • int main()
    {
        int a[]={20, 30, 40}; // ok
        int *p = new int; // ok
        *p = 10; // ok
        int *q = a;
        // Schritt 1
        //a[0]=20, a[1]= 30, a[2]=40, p=2000(p ist die addresse des ints, *p ist der wert der addresse auf den p zeigt)
       // *p=10, q=1000 (das selbe mit q), *q=20 (wobei *q halt das erste array element ist
    
        *q = *p
        //Schritt 2
        //Veränderungen: a[0]=10, q=10 (<--- das muss *q sein anstatt q)
        // somit ist a nun ==> a[] = {10, 30, 40};
    
        q=p;  // jetzt zeigt q auf p, also zeigt q auf den wert hinter p --> *q = 10
        p= &a[1]; // ok, p zeigt nicht mehr auf die reservierte 10 sondern auf das erste array element
        ++p; // p wird um 1 erhöht, also um 1 byte, ein int besteht aber aus 4 byte. p zeigt somit auf "a[1,25]" quasi
        *p= 7; // und jetzt schreibst du ab der stelle einen int der 7 ist
        //schritt 3
        //Veränderungen: a[2]=7, p=2008, *p=7, q= 2000
    
        p-=1; // dasselbe rückwärts
        *q=*p; // *q hat jetzt den wert von a[1] in dem reservierten int speicher
        //schritt 4
        //Veränderungen: p=2004, *p=30, *q=30
    
        *p = *(p+1) * *q; // das heisst das *p den wert hat: wert hinter *q multipliziert mit dem 2. array element
        //schritt 5
        //Veränderungen: a[1]= 210, p=30, *p=210 
    }
    

    wobei ich mir mit den 1.25 nicht sicher bin



  • ++p; // p wird um 1 erhöht, also um 1 byte, ein int besteht aber aus 4 byte. p zeigt somit auf "a[1,25]" quasi

    ++p erhöht den Zeiger um den Wert von TYP p also INT 4 Byte! Somit zeigt p auf a[2].



  • Vielen Danke für die guten Antworten jetzt habe ich es verstanden. Danke


Anmelden zum Antworten