Friend Funktionen in Komponenten-Funktionen wandeln --Fragen

Epimetheus

Hallo zusammen

Für mein Informatik2 Praktikum sollten wir eine Klasse safe_int schreiben, in der Zahlbereichsüberschreitungen während des Rechnes mit Integerzahlen erkannt werden. Dieses Programm habe ich mit viel Unterstützung zum Laufen gekriegt. In der neuen Aufgabe sollen wir die bisher als friend vereibarten Operatorfunktionen in Komponentenfunktionen umwandeln und die Klasse dann noch erweitern. Allerdings habe ich keine Ahnung wie das funktioniert bzw. wie ich das aufschreiben soll. Ich poste mal die Klasse safe_int und eine Operatorfunktion safe_int operator+:

Code

class safe_int{
   private:
      int val;                                     //der eigentliche Zahlwert eines safe_int
      static const string limit_string;    //die max Zahl als String (21474.....)
      static string lim_to_string();       //die Umwandelfunktion für zahl in string
      static int divi(int,int);
      static int mod(int,int);

   public: 
      static const int lim;                    //die max Zahl als in (21474......)      
      class overflow {                        //die Fehlerklasse
      	public:
		int op1,op2;
		char func[30];
		overflow(char *f,int i,int j){
			op1=i;
			op2=j;
			strcpy(func,f); 
		                             }
	    };//of class overflow 


      safe_int(string zahl);                                   //der Stringkonstruktor
      safe_int() throw() {val=0;}                         //der Defaultkonstruktor

      friend safe_int operator+(safe_int,safe_int);   //Um diese Funktion geht es!
      friend safe_int operator-(safe_int,safe_int);
      friend safe_int operator*(safe_int,safe_int);
      friend safe_int operator/(safe_int,safe_int);
      friend safe_int operator%(safe_int,safe_int);
      friend ostream& operator<<(ostream&,safe_int);
      friend istream& operator>>(istream&,safe_int&);         
};

Alles anzeigen

Und im Anschluss gleich die friend safe_int operator+(safe_int,safe_int) Funktion:

Code

safe_int operator+(safe_int a,safe_int b){
    safe_int erg;
    if((b.val>0 && a.val>safe_int::lim-b.val) || (b.val<0 && -a.val>safe_int::lim+b.val)){
       throw safe_int::overflow("Addition",a.val,b.val);       
                                                                      }
    erg.val=a.val+b.val;                                                                  
return erg;    
}

Es wäre super wenn mir jemand diese Operatorfunktion in eine Komponentenfunktion umwandeln könnte. Das geht bestimmt sehr leicht, allerdings haben im Semester aus Krankheitsgründen die Profs gewechselt und der neue ist ein Buch mit sieben Siegeln. Nicht nur für mich

thx
Epi

Wasserleiche

Also ich werde dir die Aufgabe jetzt nicht lösen, aber hier mal ein paar Tipps:

1. friend brauchst du bei Memberfunktionen nicht mehr.

2. du bekommst als Parameter nur noch einen safe_int übergeben, der zweite ist das eigentliche Objekt (this, also dieses Objekt auf dem du dann arbeitest).

3. gibt immer eine Referenz auf safe_int zurück, damit so was geht:

Code

a = b + c + d; // a,b,c,d sind safe_int

Ach und ich muss sagen, dass ich das mit dem String-ctor nicht versehe. Warum nicht ein Integer-ctor "safe_int(int zahl);" ? Wäre das nicht sinnvoller?

Epimetheus

mit nem Int Konstruktor könnte man mit

Code

int i;
cin>>i;
safe_int si(i);

für i=300000000000000000 die sichere Eingabe wieder aushebeln. Deswegen ein char oder stringkonstruktor,indem man die Zahl auf gültigkeit überprüft und weil dann safe_int und double/int Verknüpfungen nicht mehr möglich sind, kann man die Operatorfunktionen auch gleich als Member machen. So die offizielle Erklärung. Hab ich ja auch soweit begriffen.

Die ersten zwei Punkte die du erwähnst verstehe ich auch soweit (mit dem *this muss ich mir nochmal anschauen...hatten wir noch nicht. Alllerdings hab ich das gerade auch irgentwo gelesen.).
Der dritte Punkt ist mir noch ein Rätsel:
Das mit dem Referenz zurückgeben habe "ich" ja auch schon beim >>Operator benutzt und da auch nocht nicht kapiert. Warum ist a=b+c+d nur möglich wenn man eine Referenz zurückgibt? hmm...ich les mir das Kapitel mit Referenzen nochmal durch, aber wenn du eine gut verständliche Erklärung kennst wäre ich dankbar.
Grüße und danke für die Hilfe bislang

Epimetheus

Ich hab jetzt schon ein bischen rumgebastelt, allerdings widersetzt sich dieses Problem mir etwas:

Code

safe_int::safe_int& operator+(safe_int b){
    safe_int erg;
    if((b.val>0 && this->val>lim-b.val) || (b.val<0 && -this->val>lim+b.val)){
       throw overflow("Addition",this->val,b.val);       
                                                                      }
    erg=this->val+b.val;                                                                  
return erg&;    
}

Der Compiler meckert, dass man this nicht in einer "non member function" benutzen darf. Also hab ich es noch nichtmal geschafft ihm zu sagen, dass das ein Member sein soll.
Allerdings habe ich das eigentlich genauso aufgeschrieben wie für den Stringkonstruktor, den ich auch ausserhalb der Klasse definiere:

Code

safe_int::safe_int(string zahl){...}

Und das erkennt er richtig als Member.

Edit:
Soo...Fehler gefunden. Es muss (grundsätzlich heißen):

Code

safe_int& safe_int::operator+(safe_int b){
    safe_int erg;
    if((b.val>0 && val>lim-b.val) || (b.val<0 && -val>lim+b.val)){
       throw overflow("Addition",val,b.val);       
    erg.val=val+b.val;                                                                  }                                                                  
return erg;    
}

Allerdings funktioniert die Addition so nicht richtig. safe_int erg ist ja nur eine lokale Variable und Referenzen auf diese zurückgeben ist nicht so sehr sinnvoll. Jetzt muss ich nur noch herausfinden was man hier am besten returned.

btw: Wen dieses Forenselbstgespräch nervt...einfach nicht beachten

Wasserleiche

Find ich super wie du deine Probleme selbst gelöst hast. Und du hast recht, eine Referenz auf eine lokale Variable ist nicht sinnvoll.

Deswegen solltest du die Variable erg komplett weglassen, und stattdessen auf dem aktuellen Objekt arbeiten:

Code

safe_int& safe_int::operator+(safe_int b)
{
    if((b.val>0 && val>lim-b.val) || (b.val<0 && -val>lim+b.val)) {
        throw overflow("Addition",val,b.val);
    }
    val = val + b.val;
    // oder
    // val += b.val;
    return (*this);   
}

Epimetheus

Perfekt

Sowas in der Richtung hab ich auch ausprobiert allerdings ist mir n00b

Code

val=val*b.val;

in die Fehlerabfrage reingerutscht und somit war 10+20 immer 10.:P
Aber jetzt läufts und die anderen Operatoren werden auch nicht mehr so das Problem sein. Das Wochenende ist gerettet
Danköööö

Tags