Fehler im Code



  • Hi,

    wo liegt denn da der Fehler / die Fehler? Geht das folgende im Konstruktor? Hab
    ja den =-Operator überladen:

    class hugeInt {
    private:
    	int* m_zahlen;
    	int m_anzZahlen;
    
    public:
    /*** Struktoren ***/
    	hugeInt(unsigned int zahl = 0);
    	~hugeInt();
    	hugeInt(const hugeInt& hI);
    
    /*** Operatorüberladungen ***/
    	// Zuweisungsoperatoren
    	hugeInt& operator=(hugeInt hI);
    	hugeInt& operator=(unsigned int zahl);
    
    	// Umwandlungoperator
    	operator int();
    
    	// Vergleichsoperatoren
    	bool operator==(hugeInt hI);
    	bool operator!=(hugeInt hI);
    	bool operator<(hugeInt hI);
    	bool operator>(hugeInt hI);
    	bool operator<=(hugeInt hI);
    	bool operator>=(hugeInt hI);
    
    	// iostream-Operatoren
    	friend ostream& operator<<(ostream& os, hugeInt hI);
    	friend istream& operator>>(istream& is, hugeInt hI);
    };
    
    hugeInt::hugeInt(unsigned int zahl ) {
    	*this = zahl;
    }
    
    hugeInt::~hugeInt() {
    	delete [] m_zahlen;
    }
    
    hugeInt::hugeInt(const hugeInt& hI) {
    	*this = hI;
    }
    
    hugeInt& hugeInt::operator=(hugeInt hI) {
    	m_anzZahlen = hI.m_anzZahlen;
    	m_zahlen = new int[m_anzZahlen];
    	for (int i = 0; i < m_anzZahlen; i++)
    		m_zahlen[i] = hI.m_anzZahlen;
    	return *this;
    }
    
    hugeInt& hugeInt::operator=(unsigned int zahl) {
    	int tmp = 0, tmp2 = zahl;
    	do {
    		++tmp;
    	} while ((zahl /= 10) > 10);
    	m_anzZahlen = tmp;
    
    	m_zahlen = new int[m_anzZahlen];
    	for (int i = m_anzZahlen-1; i >= 0; i--)
    		m_zahlen[i] = tmp2 /= 10;
    	return *this;
    }
    
    bool hugeInt::operator==(hugeInt hI) {
    	if (m_anzZahlen == hI.m_anzZahlen) {
    		for (int i = 0; i < m_anzZahlen; i++)
    			if (m_zahlen[i] != hI.m_zahlen[i])
    				return false;
    	}
    	return true;
    }
    
    bool hugeInt::operator!=(hugeInt hI) {
    	if (*this == hI)
    		return false;
    	return true;
    }
    
    bool hugeInt::operator<(hugeInt hI) {
    	if (m_anzZahlen == hI.m_anzZahlen) {
    		for (int i = 0; i < m_anzZahlen; i++)
    			if (m_zahlen[i] < hI.m_zahlen[i])
    				return true;
    	}
    	else if (m_anzZahlen < hI.m_anzZahlen) {
    		return true;
    	}
    	return false;
    }
    
    bool hugeInt::operator>(hugeInt hI) {
    	if (!(*this<hI)&&(*this!=hI))
    		return true;
    	return false;
    }
    
    bool hugeInt::operator<=(hugeInt hI) {
    	if (!(*this>hI))
    		return true;
    	return false;
    }
    
    bool hugeInt::operator>=(hugeInt hI) {
    	if (!(*this<hI))
    		return true;
    	return false;
    }	
    
    ostream& operator<<(ostream& os, hugeInt hI) { 
    	for (int i = 0; i < hI.m_anzZahlen; i++)
    		os<<hI.m_zahlen[i]; 
    	return os; 
    }
    
    istream& operator>>(istream& is, hugeInt hI) {
    	unsigned int zahl;
    	is>>zahl;
    	hI = zahl;
    	return is;
    }
    
    hugeInt::operator int() {
    	int zahl = 1, potenz = 1;
    	for (int i = this->m_anzZahlen-1; i >= 0; i--) {
    		for (int j = 1; j <= this->m_anzZahlen-i-1; j++)
    			potenz += 10;
    		zahl += this->m_zahlen[i]*potenz;
    		potenz = 1;
    	}
    	return zahl;
    }
    


  • Du bist witzig. Wie soll sich der Fehler, den wir finden sollen, denn äußern?



  • Ist das jetzt eine Denksportaufgabe? Wenn du ein Problem mit dem Code hast, kannst du das gerne dazuschreiben.

    was auf den zweiten Blick auffällt: Deine Vergleichsoperatoren sollten (a) ihre Parameter als const-Referenzen übernehmen (erspart dir unnötige Kopien) und (b) selber als "const" definiert sein (ermöglicht die Verwendung von temporären Werten). Und der Eingabe-Operator muß seinen zweiten Parameter als Referenz übergeben, wenn du die eingegebenen Werte irgendwie verwenden willst. Außerdem nutzt letzterer den möglichen Wertebereich deiner hugeInt nicht mal annähernd aus.

    PS: Und ich hätte anstelle der nackten int-Zeiger lieber std::vector<int> verwendet.



  • Wenn man die Operatoren verwendet. Soweit ich beurteilen kann müssten die Vergleichsoperatoren gehen. Aber was ist mit den anderen?



  • Sry, hab deinen Beitrag nicht mehr gelesen. Was meinst du, die Funktionen
    sollen selber const sein? Und wie soll ich den beim Eingabeoperator das
    verbessern (strings?)?



  • Fehler schrieb:

    Was meinst du, die Funktionen sollen selber const sein?

    So, wie sie jetzt dastehen, könnten die Funktionen den verglichenen Wert ändern (daß sie es nicht machen, sieht der Compiler an den relevanten Stellen nicht), also kannst du keine Werte vergleichen, die nicht änderbar sind (da würde schon std::set<hugeInt> die Zusammenarbeit verweigern).

    Besser sieht es so aus:

    class hugeInt
    {
      ...
    public:
      bool operator<(const hugeInt& hI/*vermeidet unnötige Kopien*/) const;/*anwendbar auf konstante Objekte*/
      ...
    };
    

    Und wie soll ich den beim Eingabeoperator das
    verbessern (strings?)?

    Ja, Strings wären eine Möglichkeit für die Eingabe - die mußt du dann natürlich noch auswerten, um deine Ziffernliste zu erhalten.


Log in to reply