Sorry Pointer kapiere ich nicht!



  • Es heißt doch so schön Pointer speichern die Adresse einer Variable.
    Und was passiert meinem Verständis nach ?
    Die Funktion square benötigt als Übergabeparameter eine Zeigervariable, also
    eine Variable die die Adresse einer Variable hat.

    void square(int *p) //int *p == Adresse ??
    {
    *p *= *p; // Meiner Meinung nach wird exakt hier
    } // eine Adresse mit der anderen Adresse
    // multipliziert oder??????



  • Nein, also pass auf:
    int *P bedeutet, dass man ne Zeigervariable vom Typ int haben möchte

    *p bedeutet auf den Wert zugreifen den das Ziel hat
    p ist die Adresse der Variablen

    *p *= *p bedeuter den wert in p mit dem wert in p multiplizieren



  • Hi!
    Wie kann wenn das, "int *P" eine Zeigervariable vom Typ int haben möchte bedeutet
    in der nächsten Zeile mit der selben Schreibweise *p *= *p
    den wert in p mit dem wert in p multiplizieren bedeuten.
    Einmal fungiert es als Adresse das nächste Mal als Wert der Variable die
    hinter der Adresse steckt???



  • Bei der definition als Hinweis, dass es ein Zeiger ist und bei späterem gebrauch
    um den Wert zu erhalten und wenn der Compiler so etwas sieht *p = *p * *p, dann
    schaut er was für ein Zeiger es ist und es ist ein einfacher, also Wert holen
    und den wert vom zweiten Zeiger holen welches der gleiche ist, da er weiß es ist
    ein einfacher, weiß er in der mitte ist eine Multiplikation gemeint.
    Bei einem Zeiger auf ein Zeiger würde es so aussehen:
    int **p;

    **p = **P * **p;

    Edit:
    Lies dir dies mal durch:
    http://www.pronix.de/C/standard_C/c_programmierung_15.shtml



  • SirLant heißt es im Klartext es gibt immer 2 Stufen.
    1 Stufe = bei der definition
    2 Stufe = später den Wert zu erhalten

    Wenn es dem so ist ...
    Könntest du mir vielleicht 2 oder 3 Fragen stellen die Beantworte um sicher zu gehen ob ich es auch wirklich kapiert habe??



  • Tauboga schrieb:

    Könntest du mir vielleicht 2 oder 3 Fragen stellen die Beantworte um sicher zu gehen ob ich es auch wirklich kapiert habe??

    char* p="0123456789";
    puts(p+1);
    puts((*p)+1);
    

    Was wird ausgegeben?

    void twice(int* i)
    {
      //was ist richtig
      i += *i;
      *i += i;
      i += i;
      *i += *i;
    }
    

    Was wird ausgegeben:

    int i=2;
    int* p=&i;
    i=3;
    printf("%d\n",*p);
    printf("%p\n",p);
    
    int arr[]={1,2,3};
    p=arr;
    printf("%d\n",*p);
    printf("%d\n",p[0]);
    

    was wird ausgegeben

    int i1=2;
    int i2=2;
    int* p1=&i1;
    int* p2=&i2;
    if(p1==p2)
    {
      puts("gleich");
    }
    else
    {
      puts("ungleich");
    }
    

    und zum schluss:

    warum ist

    char* p="Hallo";
    char* p2="Welt";
    char* p3=p+p2;
    

    nicht erlaubt?



  • Tauboga schrieb:

    Wie kann wenn das, "int *P" eine Zeigervariable vom Typ int haben möchte bedeutet
    in der nächsten Zeile mit der selben Schreibweise *p *= *p
    den wert in p mit dem wert in p multiplizieren bedeuten.

    Eine simple Deklaration (ohne Initialisierung o.ä.) besteht aus 2 Teilen, das ist einmal ein Typ T und ein «Deklarator» D.

    T D ;
    

    bei int *p ist also T = «int» und D = «* p». Die Denkweise dahinter ist nun folgende: D ist vom Typ T. D.h. * p soll den Typ int haben. Da der *-Operator auf Zeiger angewendet wird, muß folglich p ein Zeiger sein. Das klappt sogar bei komplizierten Deklarationen ziemlich gut:

    int (*v[10])()
    

    (*v[10])() hat den Typ int
    => *v[10] kann mit () aufgerufen werden, muß also eine Funktion sein, die int zurückgibt
    => v[10] kann ich dereferenzieren, also ist es ein Zeiger, der auf eine int-Funktion zeigt
    => v ist ein Array.

    ==> v hat den Typ «Array von Zeigern auf Funktionen, die int zurückgeben»



  • Lieber Shade of Mine habe versucht die Aufgaben zu lösen
    ohne irgendwo nachzuschauen(Compiler) Weiss nicht ob die Lösungen
    richtig sin oder falsch.Aber danke dass du dir die Mühe für die Aufgaben gemacht hast.

    char* p="0123456789"; 
    puts(p+1);    //Ausgabe 123456789
    puts((*p)+1);  //keine Ahnung ???
    
    void twice(int* i) 
    { 
      //was ist richtig 
      i += *i; 
      *i += i; 
      i += i; 
      *i += *i; //ist richtig
    
    int i=2; 
    int* p=&i; 
    i=3; 
    printf("%d\n",*p); //Ausgabe 2
    printf("%p\n",p);  //Ausgabe  Adresse von 2
    int arr[]={1,2,3}; 
    p=arr; 
    printf("%d\n",*p);   Ausgabe 1
    printf("%d\n",p[0]); Ausgabe 1
    
    }
    
    int i1=2; 
    int i2=2; 
    int* p1=&i1; 
    int* p2=&i2; 
    if(p1==p2) 
    { 
      puts("gleich");    //Ausgabe gleich
    } 
    else 
    { 
      puts("ungleich"); 
    }
    
    char* p="Hallo"; 
    char* p2="Welt"; 
    char* p3=p+p2;      Vielleicht so char *p3=(*p)+(*p2);
    


  • Tauboga schrieb:

    char* p="0123456789"; 
    puts(p+1);    //Ausgabe 123456789
    puts((*p)+1);  //keine Ahnung ???
    

    *p ist '0'
    und '0' + 1 ist '1'
    aber ich muss zugeben hier einen fehler gemacht zu haben.
    statt puts((*p)+1); muss es putchar((*p)+1); heissen (sorry, war spaet in der nacht)
    die ausgabe ist somit '1'
    bei puts((*p)+1); wuerde bloedsinn rauskommen.

    void twice(int* i) 
    { 
      //was ist richtig 
      i += *i; 
      *i += i; 
      i += i; 
      *i += *i; //ist richtig
    

    korrekt

    int i=2; 
    int* p=&i; 
    i=3; 
    printf("%d\n",*p); //Ausgabe 2
    printf("%p\n",p);  //Ausgabe  Adresse von 2
    int arr[]={1,2,3}; 
    p=arr; 
    printf("%d\n",*p);   Ausgabe 1
    printf("%d\n",p[0]); Ausgabe 1
    
    }
    

    falsch.
    p zeigt auf i, wenn wir jetzt i aendern, dann zeigt p immer noch auf i, und somit auf den neuen wert von i - die antwort muss also
    //Ausgabe 3
    //Ausgabe Adresse von i
    heissen
    die unteren beiden sind korrekt

    int i1=2; 
    int i2=2; 
    int* p1=&i1; 
    int* p2=&i2; 
    if(p1==p2) 
    { 
      puts("gleich");    //Ausgabe gleich
    } 
    else 
    { 
      puts("ungleich"); 
    }
    

    falsch
    denn p1==p2 vergleich ob die zeiger auf die selbe adresse zeigen.
    waere dort if(*p1==*p2) gestanden, waeren sie gleich, denn i1==i2
    Aber hier werden die Adresse von i1 und i2 verglichen
    also quasi
    if(&i1==&i2)

    char* p="Hallo"; 
    char* p2="Welt"; 
    char* p3=p+p2;      Vielleicht so char *p3=(*p)+(*p2);
    

    das war fies - da hast du raten muessen.
    die antwort ist: es geht nicht, denn eine adresse + eine andere adresse ergibt bloedsinn
    du hast hier 'H'+'W' gerechnet, also die beiden buchstaben addiert, ergibt natuerlich auch bloedsinn.

    Zeiger kann man nicht addieren, nur subtrahieren.

    Fazit:
    du hast es noch nicht ganz verstanden, bist aber schon auf einem gute weg dorthin

    wenn du
    A Tutorial on Pointers and Arrays in C
    durchgelesen hast, dann hast du zeiger wahrscheinlich wirklich verstanden.

    Zeiger sind ein sehr kompliziertes Thema, aber du bist auf dem richtigen weg - nicht entmutigen lassen.


Log in to reply