Problem mit Zeigern



  • ich habe mal ne Frage zu den Zeigern in c
    und zwar zeiger werden ja mit dem dereferenzierungsoperator * deklariert.
    bsp int * z ;

    jetzt weiß ich aber nicht wie die wieder aufgerufen werden.
    ein zeiger nimmt ja keinen wert an sondern "zeigt" auf adressen ?

    z.b

    int var;
    int *ptr ;/ptr für pointer

    ptr =& var ; // hier wird ja die var adresse an den pointer gegeben
    *ptr = 10 ; // jetzt weise ich ja dem pointer den wert 10 zu oder der adresse? möchte mal gerne wissen warum an dieser stelle ein * kommt
    wird die 10 in die variable var geschrieben ?
    ne kleine gute erklärung für einen c neuling wäre perfekt 🙂

    vielleicht habt ihr experten ja auch noch ne paar tipps und tricks für mich im umgang mit zeiger , in meinem "tollen c buch" stand nur
    Pointer ein wichtiges hilfmittel in c - und dann dieses tolle bespiel , WoW 😞

    danke schonmal für antworten

    mfg,märies



  • pointer egal welchen typs sind an sich auch nur zahlen, die aber als adressen interpretiert werden.

    int a = 10, b; /* a deklarieren und 10 zuweisen */
    int *p; /* ein pointer auf int */
    a = 10; /* a ist 10 */
    p = &a; /* p bekommt die adresse von a zugewiesen */
    *p = 20; /* a ist jetzt 20 */
    b = (*p) * 2; /* b ist 40 */
    

    beim vorletzten statement wird der wert von p (die adresse von a) "dereferenziert". damit ist er wie eine variable ansprechbar.
    beim letzten statement hab ich p wieder dereferenziert und in einem ausdruck verwendet. statt *p hätte ich auch a nehmen können, weil p auf den wert von a zeigt.

    pointer sind so hilfreich, weil man sie z.b. benutzen kann, um aus einer funktion mehrere rückgabewerte zu liefern. man übergibt pointer und ändert damit direkt die eingabewerte, die nach der funktion weiter genutzt werden.
    will man arrays an funktionen übergeben, wird eigentlich auch nur die adresse vom ersten element übergeben.

    das pronix.de tutorial wird oft erwähnt, also tu ich das auch mal 🙂

    bei dem sind anschauliche grafiken dabei:
    http://www.cplusplus.com/doc/tutorial/tut3-3.html

    das hab ich noch mit google gefunden:
    http://pweb.netcom.com/~tjensen/ptr/pointers.htm



  • Bedanke mich erstmal für die schnelle antwort
    bringt mich schon was weiter 🙂
    allerdings stehe ich gerade vor einem neuen problem
    und zwar habe ich diese aufgabe gefunden

    [code]
    float funktion ( float * pa )

    {

    float x = 10.0;

    *pa = *pa + *pa;

    x = x*x + *pa;

    return x;

    }

    void main()

    {

    float x;

    float y = 5;

    x = funktion ( &y );

    x = x + y;

    printf( "%f" , x );

    }
    [\code]

    nach meiner Meinung würde da 105 raus kommen - der compiler sagt aber 120 😞

    ich kann allerdings auch nichts mit der zeile *pa = *pa + *pa anfangen
    die ist doch sinnlos oder nicht ?
    dem zeiger wird nirgendwo eine adresse zugeteilt oder doch ?
    deshalb würde ich sagen x = 10 * 10 = 100 - x wird zurück gegeben
    und dann bin ich mir nichtmehr so sicher.
    da steht ja funktion(&y) - das würde beteuten , x wird die funktion y zugewiesen , die gibt es aber doch garnicht ?
    vondaher würde ich sagen x = 100 + 5 = 105

    danke nochmal 🙂



  • float funktion ( float * pa )
    
    {
    
    float x = 10.0;
    
    *pa = *pa + *pa; // y=*pa=5+5=10
    
    x = x*x + *pa; // 10*10+10=110
    
    return x;
    
    }
    
    void main()
    
    {
    
    float x;
    
    float y = 5; //y =5
    
    x = funktion ( &y ); --> x=110
    
    x = x + y; // x=110+10=120 --> siehe *pa = *pa + *pa; // y=*pa=5+5=10 in funktion()
    
    printf( "%f" , x ); // 120
    
    }
    


  • #include <stdio.h>
    
    float funktion ( float * pa ) {
      float x = 10.0;
      *pa = *pa + *pa;
      x = x*x + *pa;
      return x;
    }
    
    int main() {
      float x;
      float y = 5;
      x = funktion ( &y );
      x = x + y;
      printf( "%f" , x );
    
      return 0;
    }
    

    Dem Zeiger pa wird durch den Funktionsaufruf in main die Adresse von y mitgegeben.

    *pa = *pa + *pa
    // enspricht also
    y = y + y
    

    Aessina schrieb:

    da steht ja funktion(&y) - das würde beteuten , x wird die funktion y zugewiesen , die gibt es aber doch garnicht ?

    Du hast das Prinzip der Pointer noch nicht verstanden.
    Der Funktion funktion wird die Adresse auf einen float mitgegeben und nicht eine Funktion.
    Ersetze einfach mal die Variablen durch Werte und rechne das durch. Denk aber dran, dass die Funktion function die Variable in main ändert.



  • ich bin im erklären leider nicht so gut, aber ich versuchs trotzdem mal

    float funktion ( float * pa ) // pa ist der zeiger auf y
    { 
      float x = 10.0; 
    
      *pa = *pa + *pa; // der wert der variablen y(!!) wird verdoppelt
                       // denn pa zeigt ja auf die variable y in main()
    
      x = x*x + *pa;   // ==100.0*100.0+10.0==110.0 - 10.0 ist der verdoppelte wert von y
    
      return x; 
    } 
    
    void main() 
    { 
      float x; 
    
      float y = 5; 
    
      x = funktion ( &y ); übergebe den zeiger auf y
    
      x = x + y; // == 110.0 + 10.0 (!!) == 120.0, denn y wurde in funktion() ja verdoppelt!
    
      printf( "%f" , x ); 
    
    }
    

    der wert des zeigers pa ist natürlich initialisiert, denn der wert für pa wird ja der funktion als parameter übergeben. nämlich &y. also die adresse der speicherstelle an der y liegt.

    der ausdruck *pa liefert den wert, der an der stelle gespeichert ist, auf die pa zeigt. in deinem beispiel ist das der wert der variablen y aus main().

    *pa=irgendwas weist der speicherstelle einen wert zu, auf die pa zeigt. in deinem beispiel also der variablen y aus der funktion main()! es ist wichtig, daß du verstehst, daß damit der wert der variablen y in main() verändert wird! deshalb liefert x=x+y; auch nicht 115 sondern 120. der wert von y wird in funktion() verdoppelt.

    *pa=*pa+*pa hat den selben effekt wie y=y+y.



  • ich danke euch erstmal für die Antworten 🙂
    das problem ist für mich einfach bei solchen aufgaben , dass ich nicht recht weiß wo die zeiger jetzt hinzeigen und und und ..
    habe noch einmal eine aufgabe gefunden

    float * funktion_1 ( float * pa)
    
    {
    
    *pa = *pa + 10.0;
    
    return pa;
    
    }
    
    void funktion_2 ( float *pa )
    
    {
    
    float *x = pa;
    
    *x = *x + 25;
    
    }
    
    void main()
    
    {
    
    float x = 10.0;
    
    funktion_2 ( funktion_1( &x ) );
    
    printf( "%f" , x );
    
    }
    

    mit dieser aufgabe kann ich eigentlich fast garnichts anfangen 😞
    ich weiß das funktion_2 erstmal funktion 1 aufruft und sich da den x wert holt obwohl ich mir da auch noch nicht mal so sicher bin.

    z.b

    in funktion 1 ist
    *pa = *pa + 10 ;
    welchen wert bekommt pa ? den x wert? also *pa = x(10.0) + 10 = 20 ?
    dann gibt return ja pa zurück an main

    anschließend würde es in funktion 2 gehen
    float *x = pa
    da wird ein float zeiger deklariert der die adresse von pa bekommt ?
    als nächstes kommt ja
    *x = *x + 25 ;
    wäre für mich jetzt *x ( aus main - von funktion 1 = 20 + 25 )
    d.h 45
    also *x = 45 ?
    wäre nett von euch mir bei dieser aufgabe nochmal zuhelfen und schritt für schritt meine fragen zu beantworten
    damit ich das auch mal irgendwann checke 😞
    tut mir leid für so dumme fragen hier

    mfg,marius



  • sry für die anderen posts - forum hatte irgendwie gelaggt



  • sry für die anderen posts - forum hatte irgendwie gelaggt



  • kann mir keiner helfen 😞



  • rücke den code ordentlich ein, druck ihn aus.
    dann nimm ein leeres blatt und nen bleistift und schreib dir dran, welche variablen/funktionen wann welche werte haben.



  • Aessina schrieb:

    ich weiß das funktion_2 erstmal funktion 1 aufruft

    Nein. Beide Funktionen werden nacheinander aufgerufen. Folgender Code

    funktion_2 ( funktion_1( &x ) );
    

    wird vom Compiler wie folgt verarbeitet

    tmp = funktion_1( &x ); // "tmp" ist eine vom Compiler erstellte temporare Variable, welche nach dem Aufruf von funktion_2 wieder zerstoert wird
    funktion_2 ( tmp );
    

    funktion_1 wird ja die Adresse von x übergeben. Jetzt gehst du einfach Schritt für Schritt beide Funktionen durch und schaust, wie sich x dabei verändert.



  • deine beschreibung dessen, was der 2. beispielcode, tut war völlig korrekt. wenn du uns jetzt noch sagen kannst, was

    printf( "%f" , x );
    

    für einen wert ausgibt, dann hast du die zeigerkiste kapiert.


Log in to reply