Friend Funktionen in Komponenten-Funktionen wandeln --Fragen

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+:

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&);         
};

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

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

mit nem Int Konstruktor könnte man mit

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

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

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:

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

Und das erkennt er richtig als Member.

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

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

Perfekt

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

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öööö