Przeciążenie operatora

Witam. Mam problem z przeciążeniem operatora +. Program ma realizować operacje matematyczne na dowolnie dużej liczbie. Kolejne cyfry tej liczby zapisuje do dynamicznie alokowanej tablicy charów (char *liczba), w zmiennej int dlugosc zapisuje ilość cyfr tej liczby. Dodawanie działa poprawnie dla 2 składników tzn liczba1 + liczba2, ale dla większej ilości (np liczba1+liczba2+liczba3) wrzuca śmieci do wyniku.

 
#include <iostream>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;

class duzeliczby
{
    public:
    char *liczba;
    int dlugosc;
    duzeliczby()
    {
        liczba=NULL;
        dlugosc=0;
    }
    ~duzeliczby()
    {
        if (liczba != NULL)
            delete[] liczba;
    }
    friend istream & operator>>(istream &in, duzeliczby &obiekt)
    {
        string schowek;
        int n;

        in >> schowek;
        obiekt.dlugosc = schowek.size();

        obiekt.liczba = new char[obiekt.dlugosc];
        memset(obiekt.liczba,'\0',obiekt.dlugosc);

        for(n=0; n < obiekt.dlugosc; n++)
        {
            obiekt.liczba[n] = schowek[n];
        }
        schowek.clear();
        return in;
    }
    friend ostream & operator<<(ostream &out, duzeliczby &obiekt)
    {
        out << obiekt.liczba;
        return out;
    }
    duzeliczby & operator=(duzeliczby &obiekt)
    {
        char *liczba_temp;

        dlugosc = obiekt.dlugosc;

        liczba_temp = new char[dlugosc];
        memset(liczba_temp,'\0',dlugosc);
        strncpy (liczba_temp,obiekt.liczba,dlugosc);

        delete[] liczba;

        liczba = new char[dlugosc];
        memset(liczba,'\0',dlugosc);
        strncpy (liczba,liczba_temp,dlugosc);

        return *this;
    }
    duzeliczby & operator+(duzeliczby &obiekt)
    {
        static duzeliczby temp;
        temp.~duzeliczby();
        int reszta, wynik, n;

        temp.dlugosc = (dlugosc>obiekt.dlugosc) ? dlugosc : obiekt.dlugosc;

        temp.liczba = new char[temp.dlugosc];
        memset(temp.liczba,'\0',temp.dlugosc);

        reszta = 0;
        for (n=1; n <= temp.dlugosc; n++)
        {
            wynik = reszta;
            wynik += (dlugosc-n >= 0) ? static_cast<int>(liczba[dlugosc-n]) - 48: 0;
            wynik += (obiekt.dlugosc-n >= 0) ? static_cast<int>(obiekt.liczba[obiekt.dlugosc-n]) -48: 0;

            if (wynik > 9)
            {
                reszta=1;
                wynik-=10;
            }
            else reszta = 0;
            temp.liczba[temp.dlugosc-n]=static_cast<char>(wynik+48);
        }
        temp.liczba[temp.dlugosc] = '\0';
        if ( reszta == 1 )
        {
            temp.resize(1);
            temp.przesuniecie(1);
            temp.liczba[0]='1';
            temp.liczba[temp.dlugosc]='\0';
        }
        return temp;
    }
    void przesuniecie(int skok)
    {
        int n;
        if (skok > 0)
            for (n=dlugosc-1; n>=skok; n--)
                liczba[n]=liczba[n-skok];
        else if (skok < 0)
        {
            for (n=-skok; n<dlugosc-1; n++)
                liczba[skok+n]=liczba[n];
        }

    }
    void resize(int zmiana)
    {
        char *schowek;
        schowek = new char[dlugosc];
        strncpy (schowek,liczba,dlugosc);
        delete[] liczba;
        dlugosc=dlugosc+zmiana;
        liczba = new char[dlugosc];
        memset(liczba,'\0',dlugosc);
        strncpy (liczba,schowek,dlugosc);
        delete[] schowek;
    }
};

int main(void)
{
    duzeliczby liczba01, liczba02, liczba03, liczba04;
    cout << "Wprowadz liczbe nr 1: ";
    cin >> liczba01;

    cout <<"Wprowadz liczbe nr 2: ";
    cin >> liczba02;

    cout << "Dodawanie licz1 + licz2: " << liczba01+liczba02 << endl; //tu jest poprawnie

    cout << "Dodawanie licz1 + licz2 + licz2: " << liczba01+liczba02+liczba02 << endl; //tu wywala smieci
    return 0;
}

Przestudiowałem fragment kodu z przeciążeniem i doszedłem do wniosku, że w momencie dodawania drugiego i trzeciego składnika ( suma(liczba01 i liczba02) + liczba02 ) do tablicy rzutuje wartość ujemna, dokładnie o 48 za małą. Mogę ten problem rozwiązać dodając 48 do wartości wynik, jeżeli ta jest ujemna, ale to prymitywne. Wolałbym zrozumieć dlaczego tak się dzieje i chciałbym Was poprosić o wytłumaczenie mi tego problemu + ewentualną poprawkę.

Wkleiłem cały kod, ponieważ nawet po eliminacji pierwszego problemu za pomocą prymitywnej poprawki, program nie dodaje jak trzeba.
Dla przykładu: 1111 + 22 + 22 = 0022

Z góry dziękuję za jakikolwiek pomysł/poradę.

duzeliczby & operator+(duzeliczby &obiekt) { ... } 

operator+ z reguły zwraca wynik przez wartość. Czyli:

duzeliczby operator+(const duzeliczby &obiekt)const
{
        duzeliczby temp;
        int reszta, wynik, n;

        ...

        return temp;
}

Sorry ale nie chce mi się przeglądać kodu bez komentarzy:/
Co mi się rzuciło w oczy to jawne wywołanie destruktora:

temp.~duzeliczby();

Tak się nie robi!

operator+ z reguły zwraca wynik przez wartość. Czyli:

duzeliczby operator+(const duzeliczby &obiekt)const
{
        duzeliczby temp;
        int reszta, wynik, n;

        ...

        return temp;
}
 

Nie jestem pewny czy to "const" po deklaracji przeciążenia jest celowo czy błędem, ale nie pomogło. Już samo usuniecie & z wartości zwracanej generuje masę błędów.

Nie jestem pewny czy to "const" po deklaracji przeciążenia jest celowo czy błędem

Jest tam celowo.

Zapomniałem dodać, musisz zrobić jeszcze konstruktor kopiujący.

p.s. tak na przyszłość: jeśli są jakieś błędy, to pisz konkretnie jakie to błędy.

Jawne wywołanie destruktora usunięte, poprawka zaproponowana przez 0x666 zastosowana, konstruktor kopiujący dopisany. Poprawiłem też przeciążenie operatora wyjścia dodając const. Wszystko zdaje się działać poprawnie :) Dziękuję za pomoc.

Jeszcze jakbym mógł prosić o wyjaśnienie, co oznacza: duzeliczby operator+(const duzeliczby &obiekt)const, oraz czemu po zamianie na const (i pominięciu static) przeciążenie poprawnie zwraca obiekt. Zazwyczaj kompilator informował o możliwej utracie danych i faktycznie wyrzucał śmieci.

Edit: Jednak coś jeszcze nie gra. Gdy wypisuje sam efekt dodawania, wszystko jest ok:

cout << liczba01 + liczba02;

gdy jedną liczbę przypisuje do drugiej, też jest dobrze:

liczba01 = liczba02;

Ale gdy próbuję połączyć obie czynności, następuje poprawne dodawanie (tzn wynik się zgadza) ale na samym końcu do wyniku dopisywane są krzaczki:

liczba01 = liczba02 + liczba03;
cout << liczba01;

Próbowałem zmienić operator przypisania ale moje starania powodują tylko błędy kompilacji.

Pisałem, że jeśli są jakieś błędy, to podaj ich treść!

Dodaj const:

duzeliczby& operator=(const duzeliczby &obiekt) { ... }

oznacza: duzeliczby operator+(const duzeliczby &obiekt)const

const na końcu oznacza tyle, że metoda ta nie zmienia stanu obiektu, więc może być wywołana dla obiektów stałych (vide parametr obiekt).

oraz czemu po zamianie na const (i pominięciu static) przeciążenie poprawnie zwraca obiekt.

Akurat const nie miał tu większego znaczenia, po prostu zwracałeś referencję na zmienną statyczną, czyli każde wywołanie operatora + zwracało i operowało na dokładnie tej samej zmiennej.

duzeliczby & operator=(duzeliczby &obiekt)
{
	...

	liczba_temp = new char[dlugosc];

	strncpy (liczba_temp,obiekt.liczba,dlugosc);

	...
	
	liczba = new char[dlugosc];

	...
	
	strncpy (liczba,liczba_temp,dlugosc);
	return *this;
}

Jaki jest sens liczba_temp? Nigdzie nie zwalniasz tej pamięci - to błąd.

friend ostream & operator<<(ostream &out, duzeliczby &obiekt)
{
	out << obiekt.liczba; //<--- !!!
	return out;
}

Nie możesz tak zrobić, ponieważ liczba nie jest c-stringiem (brak zera na końcu).

Stworzenie liczba_temp to celowy zabieg. Tak by uniknąć błędu w sytuacji, gdy do obiektu zostanie przypisany on sam (tzn gdy liczba01 = liczba01), ponieważ w trakcie przypisania czyszczona jest zawartość pierwszego obiektu. O zwolnieniu pamięci po liczba_temp faktycznie zapomniałem, dziękuję za słuszną uwagę.

Zmieniłem też operator wyjścia. Faktycznie często powodował błędy z powodu braku '\0' na samym końcu.

Stworzenie liczba_temp to celowy zabieg. Tak by uniknąć błędu w sytuacji, gdy do obiektu zostanie przypisany on sam

Wystarczy, że dasz warunek na początku:

duzeliczby & operator=(duzeliczby &obiekt)
{
	if(this == &obiekt)return *this;

	...
}

I żadne dziwne zabiegi z pamięcią nie są potrzebne.