Przeciażony operator w klasie

0

Witam
CZy mógłby ktoś poradzić ? problem powstaje na samym końcu przeciążenia wyskakuje komunikat...

invalid initialization of non-const reference of type 'DuzaLiczba&' from an rvalue of type 'DuzaLiczba'

a oto kod :

 
	DuzaLiczba::DuzaLiczba(char *liczba){
		wartosc = new char (strlen(liczba)+1);
		strcpy(wartosc,liczba);
	}

	DuzaLiczba & DuzaLiczba::operator + (const DuzaLiczba  &x){
				int lenX,lenY,mx,mn,w,przen;
		przen=0;
		lenX = strlen(x.wartosc);
		lenY = strlen(this->wartosc);
		mx = max(lenX,lenY);
		mn = min(lenX,lenY);
		char *wynik;
		wynik = new char(mx);
		
		for(int i = mx-1;i>=0;i--){
			if(lenX>=lenY){
				if(mn){
					mn--;
					w=(int)x.wartosc[i]+(int)this->wartosc[mn]-96+przen;
					wynik[i]=w%10;
					przen=w/10;
				}
				else {
					
					 w=(int)x.wartosc[i]-48+przen;
         			wynik[i]=w%10;
         			przen=w/10;
				}
			}
			else 
				if(mn)
				{
					mn--;
					w = (int)this->wartosc[i]+(int)x.wartosc[mn]-96+przen;
					wynik[i]=w%10;
					przen=w/10;
				}
				else
				{
					w=(int)this->wartosc[i]-48+przen;
					wynik[i]=w%10;
					przen=w/10;
					
				}
		}
		if(przen)	return DuzaLiczba('1'+wynik);
		else 	return DuzaLiczba(wynik);
  
	}
0

Zwracasz referencję na obiekt, który zaraz straci ważność.
Zmień funkcję na

DuzaLiczba &&DuzaLiczba::operator + (const DuzaLiczba  &x)

(Tak jak podpowiada kompilator)
lub ewentualnie

const DuzaLiczba &&DuzaLiczba::operator + (const DuzaLiczba  &x)
0

a w

 
DuzaLiczba & DuzaLiczba::operator = (DuzaLiczba  &dl){
			 this->wartosc=dl.wartosc;
	}

też mam błąd ?
bo dla sytuacji :

 DuzaLiczba x ("145");
 DuzaLiczba y ("199");
 cout<<x;
 x=y;
 cout<<x; 

działa poprawnie ale gdy zapisze :

  DuzaLiczba x ("145");
 DuzaLiczba y ("199");
 cout<<x;
 x=x+y;
 cout<<x;

Wywala błędy

0
DuzaLiczba & DuzaLiczba::operator = (DuzaLiczba  &dl){
             this->wartosc=dl.wartosc;
    }

tutaj powinieneś coś ustawić, nie uważasz? W tym miejscu nie tworzysz nowego obiektu
zwróć this

0

mhhh no fakt... niestety nie rozwiazalo to mojego problemu

	DuzaLiczba & DuzaLiczba::operator = (DuzaLiczba  &dl){
			 this->wartosc=dl.wartosc;
			return *this;    
	} 
0

wybacz ale nie bardzo znajduje analogii, zresztą nie widzę tam przeciążenia = .... :/

0
DuzaLiczba & DuzaLiczba::operator = (const DuzaLiczba  &dl)
0

dziwna rzecz się dzieje, bo skubaniec teraz mi nie zamienia wyniku na int. mianowicie przy takich danych :

int main(int argc, char** argv) {
 DuzaLiczba x (2);
 DuzaLiczba y ("15");
 DuzaLiczba z ("2");
 cout<<x;
x=y+z;
cout<<x;
	return 0;
} 

Wyswietla mi cos takiego (zalacznik);

Reszta kodu :

#include "duzaliczba.h"
#include <cmath>




	DuzaLiczba::DuzaLiczba(){
		wartosc = new char[1];
         strcpy(wartosc,"0");
	}
	
	DuzaLiczba::DuzaLiczba(int liczba){
			wartosc=new char[(int)log10(abs(liczba+0.5))+(liczba<0)+2];
 		    itoa(liczba,wartosc,10);
		 
	}
	
	DuzaLiczba::DuzaLiczba(char *liczba){
		wartosc = new char (strlen(liczba)+1);
		strcpy(wartosc,liczba);
	}
	
	DuzaLiczba::DuzaLiczba(const DuzaLiczba& dLiczba){
		wartosc = new char(strlen(dLiczba.wartosc)+1);
		strcpy(wartosc,dLiczba.wartosc);
	}
//	DuzaLiczba::~DuzaLiczba(){
	//	 free(wartosc);
    //	wartosc = 0;
//	}
	
	
	ostream & operator<< (ostream &wyjscie, const DuzaLiczba &dLiczba){
		return wyjscie << dLiczba.wartosc;
	}
	istream & operator>> (istream &wyjscie, const DuzaLiczba &dLiczba){
		return wyjscie >> dLiczba.wartosc;
	}
	DuzaLiczba & DuzaLiczba::operator = (const DuzaLiczba  &dl){
			 this->wartosc=dl.wartosc;
			return *this;
	}
	
	
	const	DuzaLiczba & DuzaLiczba::operator + (const DuzaLiczba  &x){
				int lenX,lenY,mx,mn,w,przen;
		przen=0;
		lenX = strlen(x.wartosc);
		lenY = strlen(this->wartosc);
		mx = max(lenX,lenY);
		mn = min(lenX,lenY);
		char *wynik;
		wynik = new char(mx);
		
		for(int i = mx-1;i>=0;i--){
			if(lenX>=lenY){
				if(mn){
					mn--;
					w=(int)x.wartosc[i]+(int)this->wartosc[mn]-96+przen;
					wynik[i]=w%10;
					przen=w/10;
				}
				else {
					
					 w=(int)x.wartosc[i]-48+przen;
         			wynik[i]=w%10;
         			przen=w/10;
				}
			}
			else 
				if(mn)
				{
					mn--;
					w = (int)this->wartosc[i]+(int)x.wartosc[mn]-96+przen;
					wynik[i]=w%10;
					przen=w/10;
				}
				else
				{
					w=(int)this->wartosc[i]-48+przen;
					wynik[i]=w%10;
					przen=w/10;
					
				}
		}
		if(przen)	return DuzaLiczba('1'+wynik);
		else 	return DuzaLiczba(wynik);
  
	}
	 
0
wynik = new char(mx);
  1. Sądząc po kodzie to raczej miało być new char[mx]
  2. Nie dodajesz nulla do końca
  3. Ta pamięć nie jest zwolniona - wyciek
0

poprawiłem błędy (przynajmniej tak mi sie wydaje) niestety wynik który otrzymuje jest nadal nie poprawny
-6422
Skąd to -64 na poczatku ?
poprawiony kod :

 	const	DuzaLiczba & DuzaLiczba::operator + (const DuzaLiczba  &x){
				int lenX,lenY,mx,mn,w,przen;
		przen=0;
		lenX = strlen(x.wartosc);
		lenY = strlen(this->wartosc);
		mx = max(lenX,lenY);
		mn = min(lenX,lenY);
		char *wynik;
		wynik = new char[mx+1];
		wynik[mx+1] = '\0';
		
		
		
		for(int i = mx-1;i>=0;i--){
			if(lenX>=lenY){
				if(mn){
					mn--;
					w=(int)x.wartosc[i]+(int)this->wartosc[mn]-96+przen;
					wynik[i]=w%10;
					przen=w/10;
				}
				else {
					
					 w=(int)x.wartosc[i]-48+przen;
         			wynik[i]=w%10;
         			przen=w/10;
				}
			}
			else 
				if(mn)
				{
					mn--;
					w = (int)this->wartosc[i]+(int)x.wartosc[mn]-96+przen;
					wynik[i]=w%10;
					przen=w/10;
				}
				else
				{
					w=(int)this->wartosc[i]-48+przen;
					wynik[i]=w%10;
					przen=w/10;
					
				}
		}
		if(przen)	return DuzaLiczba('1'+wynik);
		else 	return DuzaLiczba(wynik);
		delete wynik;
		
  
	}
0

Zacznij od tego że trzymaj swoja liczbę odwróconą w pamięci, owszem nieco skomplikuje to operator przesunięcia bitowego (dla strumienia) ale wszystkie pozostałe - uprości.
Np:

DuzaLiczba &DuzaLiczba::operator+=(const DuzaLiczba  &x)
  {
   size_t len=strlen(wartosc),xlen=strlen(x.wartosc),tlen=max(len,xlen)+2,mlen=min(len,xlen);
   unsigned przen=0,next=0;
   char *twartosc=new char[tlen],*a=wartosc,*b=x.wartosc,*c=twartosc;
   for(char *ce=c+mlen;c<ce;*(c++)=przen-10*next+'0',przen=next) next=((przen+=*(a++)-'0'+*(b++)-'0')/10);
   for(char *ae=wartosc+len;a<ae;*(c++)=przen-10*next+'0',przen=next) next=((przen+=*(a++)-'0')/10);
   for(char *be=wartosc+xlen;b<be;*(c++)=przen-10*next+'0',przen=next) next=((przen+=*(b++)-'0')/10);
   *c=0;
   swap(wartosc,twartosc);
   delete[] twartosc;
   return *this;
  }
DuzaLiczba DuzaLiczba::operator+(const DuzaLiczba  &x)const
  {
   DuzaLiczba tmp(*this);
   tmp+=x;
   return tmp;
  }
1
ice25 napisał(a):

poprawiłem błędy (przynajmniej tak mi sie wydaje) niestety wynik który otrzymuje jest nadal nie poprawny
...

wynik = new char[mx+1];
wynik[mx+1] = '\0';

Mażesz po nieswojej pamięci. wynik nie ma indeksu mx+1.

1 użytkowników online, w tym zalogowanych: 0, gości: 1