Kopierkonstruktor für ein Member-Array



  • Da das eigentliche Problem nichts mit der VCL zu tun hat, habe ich es hier gepostet. Falls falsch, bitte verschieben...

    Da ich in der Klasse CTupel ein int-Array verwende, habe ich den Kopierkonstruktor überladen:

    CTupel& CTupel::operator=(CTupel rhs)
    {       this->laenge=rhs.get_laenge();
            this->letzte_bearbeitete=rhs.get_letzte_bearbeitete();
    
            for (int i=0; i<laenge; i++)
            {       this->glied[i]=rhs.get_glied(i);
            }
    
            return *this;
    }
    

    Eigenartigerweise ändert sich der Wert von temp_tupel, genauer gesagt die Werte des int-Arrays ändern sich, bei diesem Aufruf:

    summe+=TupelAst(temp_tupel, false);
    

    Die Funktion sieht wie folgt aus:

    int TupelAst(CTupel temp_tupel, bool grund_ast)
    {       int summe=0;
            bool ast_fertig;
    
            //Falls der akutelle Ast nicht der der grundlegenede ist, Tupel rechts berechnen
            if (!grund_ast) temp_tupel.NaechstesTupelRechts();
    
            do
            {       summe+=temp_tupel.Produkt();
    
                    if (temp_tupel.NaechstesTupelRechts_pruefen())
                            summe+=TupelAst(temp_tupel, false);
    
                    ast_fertig=!(temp_tupel.NaechstesTupelUnten_pruefen());
                    if (!ast_fertig)
                            temp_tupel.NaechstesTupelUnten();
            } while(!ast_fertig);
    
            return summe;
    }
    

    Da sich wirklich nur der Wert des Arrays ändern, jedoch nicht die der restlichen Werte, habe ich einen Denkfehler beim Kopierkonstruktor vermutet.
    Falls doch noch mehr an Infos von Nöten sind:
    http://benediktibk.dyndns.org/data/Tupel_Berechnung/header.zip


  • Mod

    Das ist kein Copy-ctor sondern ein überladener Zuweisungsoperator (den du auch brauchst).



  • += ist nicht gleich =.



  • Hallo,
    Das hier

    CTupel& CTupel::operator=(CTupel rhs)
    

    ist nicht der Kopierkonstruktor, sondern der Zuweisungsoperator. Der Kopierkonstruktor würde folgendermaßen aussehen.

    CTupel(const CTupel& rhs)
    

    Den brauchst du hier. Der könnte etwa so aussehen.

    CTupel(const CTupel& src) : glied(new int[laenge]), laenge(src.laenge), letzte_bearbeitete(src.letzte_bearbeitete) 
    {
       for( int i=0; i<laenge; ++i)
           glied[i] = src.glied[i];
    }
    

    Bitte übergib auch immer per konstante Referenz. Bei deinem Zuweisungsoperator hast du deswegen auch eine unnötige Kopie drin.
    Beim Zuweisungsoperator musst du übrigens die Länge deines Arrays evtl. neu setzen (löschen, neu machen).
    Nimm statt dem Array lieber gleich std::vector (siehe Magazin).



  • Okay, wieder was dazugelernt. Ich dachte, bei dem obigen Aufruf wird der operator= aufgerufen.

    Danke für die schnelle Hilfe!

    MfG benediktibk





  • Danke für den Link. Solche Theorie sollte einmal in der Schule vorkommen, und nicht "Wie klicke ich mir eine bunte Oberfläche zusammen".

    MfG benediktibk


  • Mod

    benediktibk schrieb:

    Danke für den Link. Solche Theorie sollte einmal in der Schule vorkommen, und nicht "Wie klicke ich mir eine bunte Oberfläche zusammen".

    MfG benediktibk

    Einfach die Threads in diesem Forum verfolgen, dann kommen die meisten wichtigen Sachen relativ schnell zusammen.



  • Warum die Leute immer "this" werwenden kann ihc nicht verstehen.
    Ich mag es nicht, denn es nimmt die Übersichtlichkeit.



  • Warum die Leute immer "this" werwenden kann ihc nicht verstehen.
    Ich mag es nicht, denn es nimmt die Übersichtlichkeit.

    sieht bunter aus^^



  • Quellcode schrieb:

    Warum die Leute immer "this" werwenden kann ihc nicht verstehen.
    Ich mag es nicht, denn es nimmt die Übersichtlichkeit.

    Ich kann dir gleich mehrere Gründe für this geben:
    a) In manchen IDE's funktioniert die Codevervollständigung mit this einfach besser.
    b) Wenn man gleiche Variablennamen für Member und Parameter verwendet ist this nötig (und irgendein kryptisches Präfix wie m_ halte ich für weniger Aussagekräftig wie ein this->)...

    Jeder wie es mag, ich ziehe die this-> schreibweise jedenfalls vor. Und Übersichtlichkeit geht mir dabei eigentlich nicht verloren, liefert es doch auch Zusatzinformationen (okay, wenn man wirklich immer kurze Methoden schreibt die man auf einen Bildschirm überblicken kann, ist es nicht zwangsweise nötig).

    cu André



  • Hi,

    also ich verwende this auch nur sehr selten ... aber irgendwie würde es mir schwer fallen, da eine generelle Regel aufzustellen. Einerseits kann es bei vielen Parametern und klassischen "Settern" IMHO Übersichtlichkeit erhöhen

    // ich finde .....
    void neueWerte(int groesse, int breite, int laenge, ... ) {
       this->groesse = groesse;
       this->breite = breite;
       this->laenge = laenge;
       ...
    }
    
    // ... klarer als:
    void neueWerte(int in_groesse, int in_breite, int in_laenge, ... ) {
       groesse = in_groesse;
       breite = in_breite;
       laenge = in_laenge;
       ...
    }
    

    Aber wenn man eine ziemlich komplexe Memberfunktion hat, gehen einem die "this"-e auch ziemlich schnell "auf die Augen"

    // ohne this ...
    void berechne() {
       groesse = gefundenesFressen < wasImmer ? 
          breite * sqrt(breite2) + merkmal.getVal(actPos) > 0 :
          andererWert[neuePos].naechstes().second->val(actPos);
    }
    
    // ... oder mit:
    void berechne() {
       this->groesse = this->gefundenesFressen < this->wasImmer ? 
          this->breite * sqrt(this->breite) + this->merkmal.getVal(this->actPos) > 0 :
          this->andererWert[this->neuePos].naechstes().second->val(this->actPos);
    }
    

    Wie so oft: Es kommt drauf an.

    Gruß,

    Simon2.


Log in to reply