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.

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

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.

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.