Operatoren Überladen



  • Hallo erstmal, bin neu im Forum und habe eine Frage.

    Es geht um das Überladen von Operatoren.
    Ich habe eine Klasse BigInt mit der sich beliebig große Zahlen speichern lassen.

    Jetzt möchte ich diese natürlich auch noch addieren können und Überlade den + Operator. Die eigentlich Funktionsweise der Funktion ist dabei eigentlich klar.

    Hier mal die Funktion:

    BigInt BigInt::operator+(BigInt &BigInt2)
    {
        int i;
        int sizeOfResult = 0, temp;
        int carry = 0;
        int sizeOfBigInt1 = size();
        int sizeOfBigInt2 = BigInt2.size();
    
        part *allPartsOfBigInt1[sizeOfBigInt1];
        part *allPartsOfBigInt2[sizeOfBigInt2];
    
        if (sizeOfBigInt1 >= sizeOfBigInt2)
            sizeOfResult = sizeOfBigInt1;
        else
            sizeOfResult = sizeOfBigInt2;
    
        if ((allPartsOfBigInt1[sizeOfBigInt1]->ziffern + allPartsOfBigInt2[sizeOfBigInt2]->ziffern) >= 1000000000)
            sizeOfResult++;
    
        BigInt result(sizeOfResult);
    
        for (i = 1; i <= sizeOfResult; i++)
        {
            temp = allPartsOfBigInt1[i]->ziffern + allPartsOfBigInt2[i]->ziffern + carry;
    
            result.setPart(temp % 1000000000, i);
    
            carry = temp / 1000000000;
        }
    
        return result;
    }
    

    in meiner main sieht der Code so aus:

    ...
    
        zahl1 = zahl2 + zahl3;
    
    ...
    

    Aber ich bekomme einen Kompilerfehler:
    no match for Operator= in 'zahl1 = BigInt::Operator+(BigInt&)(((BigInt&)(&zahl3)))

    Mein = Operator ist schon Überladen und funktioniert, wenn ich schreibe: zahl1 = zahl.

    Hier aber nochmal der Code:

    BigInt BigInt::operator=(BigInt &copyNum)
    {
        if (this == &copyNum)
            return *this;
    
        destruct();
    
        int i, varSize;
    
        varSize = copyNum.size();
    
        part *allParts[varSize];
        part *workPart = zahlenteil;
    
        copyNum.returnAllParts(allParts);
    
        for (i = 1; i<=varSize; i++)
        {
            *workPart = *allParts[i];
    
            if(i < varSize)
            {
                workPart->next = new part;
                workPart = workPart->next;
            }
    
            workPart->next = NULL;
        }
    
        return *this;
    }
    

    Es wäre echt super, wenn mir jemand helfen könnte.



  • Dein operator+ liefert eine temporäre Variable, die kannst du nicht an eine nicht-konstante Referenz binden. Da du sowieso nicht vorhast, sie zu ändern, solltest du die Parameter der beiden Operatoren als const BigInt& definieren.

    (und op+ definierst du lieber als globale Funktion, dann klappen auch Ausdrücke wie "2+zahl")



  • Mach mal die Referenzen const .



  • Ich habe die Referenzen als const bezeichnet, aber immernoch selber Fehler.



  • Mach den operator+ wie schon vorgeschlagen global.

    BigInt operator+ (const BigInt& lhs, const BigInt& rhs);
    

    Zeig dann den neuen Code, aber auf ein Minimum reduziert. Lasse alles Irrelevante weg, aber so, dass der ursprüngliche Fehler immer noch reproduzierbar ist. Verwende ausserdem bitte [cpp]-Tags und nicht [code]-Tags.



  • Jetzt hat er es doch geschluckt, danke euch mal.



  • Und wenn dein Compiler C++0x kann, kannst du beim Rückgabewert die Move Semantics nutzen.



  • EOutOfResources schrieb:

    Und wenn dein Compiler C++0x kann, kannst du beim Rückgabewert die Move Semantics nutzen.

    Sollte nicht nötig sein. Falls der Typ einen Move-Konstruktor bereitstellt (und das tut er, sofern die Grossen Drei nicht selbst implementiert werden), wird dieser nach Möglichkeit automatisch verwendet.


Log in to reply