verhalten von pointer und referenzen



  • kann mir einer sagen ob folgendes konstruk ordentlich funktionieren kann

    int i = 0;
        m1(&i);
        cout<<i; // wird i hier 1 oder 0 sein?
    
    void m1(int* var)
    {
        m2(*var); // ich kann es mir nur schwer vorstellen, kann es aber sein das hier 
                  // beim dereferenzieren der bezug zur varbiable verloren geht beim 
                  // call by reference von m2() ??
    }
    
    void m2(int &var)
    {
        var++;
    }
    

    das problem kann evtl. auch woander liegen, ich schreib grad schwer mein programm um, um die ganze pointer loszuwerden, nur würde ich das konstrukt als fehlerquelle gern ausschliessen

    thx
    mfg



  • Warum probierst du es nicht einfach aus? Natürlich kommt 1 raus.



  • Durch das Dereferenzieren wird keine neue Variable erzeugt. D.h. da du die Variable nirgends kopierst, arbeitest du durchgehend mit der "int i" aus dem Hauptprogramm.

    (im Klartext: Das Ergebnis wird 1 lauten)

    PS: Warum testest du das nicht selber?



  • ja sorry, mein borland iss grad vollgestopft mit projekten und ich friemel grad am offenen herzen, will jetzt nicht ausm kontext raus sonst muss ich mich erst wieder an die stelle finden wo ich grad aufgehört hab.

    danke für die erklärung stoll, genau das wollt ich wissen ... unser prof hat sich nämlich bei call by reference immer in ungereimtheiten verstrickt (das problem lag weiter "vorne" hab da nen stern vergessen ... einer der gründe warum ich grad komplett auf call by reference umstelle)



  • Von pointern zu referenzen zu wechseln macht es nicht stabiler!
    Während du bei einem Pointer notfalls noch nach NULL checken kannst, kannst du das bei einer Referenz nicht.
    Referenzen können aber sehrwohl zur Laufzeit ungültig werden, wenn das Objekt zerstört wird z.b.
    Evtl. solltest du dir überlegen, ob du nicht auf smartpointer zurückgreifst, wie z.b. boost::shared_ptr.



  • smart pointer nein danke ... ich pass lieber selber drauf auf wann ich das objekt lösche ...
    der eigentliche grund der umstellung war, das ich zeitweilig wegen irrtümlich kopierter pointer (und nicht dessen inhalt) bei einer wertänderung über mehrere objekte hinweg einträge geändert habe (mittlerweilen passiert mir das zwar nicht mehr aber ich will das risiko minimieren und es macht den quellcode etwas übersichtlicher find ich)

    [EDIT] leider muss ich hier mit ein paar "wrapperklassen" hantieren um meine datenschicht möglichst VCL frei zu halten, deswegen so viele pointer/referenzen



  • phlox81 schrieb:

    Von pointern zu referenzen zu wechseln macht es nicht stabiler!
    Während du bei einem Pointer notfalls noch nach NULL checken kannst, kannst du das bei einer Referenz nicht.
    Referenzen können aber sehrwohl zur Laufzeit ungültig werden, wenn das Objekt zerstört wird z.b.

    Geht aber auch nur, wenn der Pointer durchgängig by-Ref übergeben wurde. Sonst sinds trotzdem zwei oder mehr verschiedene Pointer, auch wenn die auf das selbe Objekt zeigen. Da ist dann wirklich die sicherste Methode einfach nur shared_ptr zu verwenden.



  • long mem[2];
    mem[0] = 1;
    long* temp = new long[4];
    mem = temp;
    

    was passiert mit dem ursprünglichen speicher von mem ? memoryleak ? oder wird der speicher trotzdem beim verlassen der methode ordentlich freigegeben ?



  • Gar nichts - die Zuweisung wird schon vom Compiler als Fehler zurückgewiesen.

    (die Behautpung "Array=Pointer" ist sehr stark vereinfacht und schlicht falsch - du kannst ein Array implizit als konstanten Pointer verwenden, aber nicht auf einen neuen Speicherbereich umbiegen)



  • Alles daneben. Probiers einfach aus wir sind hier kein Compiler-Ersatz.


Log in to reply