die Funktion safe_add ist ja recht groß und Umfangreich. Würde es sich lohnen, einen check noch einzubauen, der nur safe_add verwendet, falls es so mit Integern zum Overflow kommen würde?:
bool mul_is_safe(int lhs, int rhs)
{
if (lhs > maxint / rhs || lhs < minint / rhs)
return false;
return true;
}
Rational& operator+=(const Rational& rhs)
{
if (!mul_is_safe(*this.num, rhs.denom) ||
!mul_is_safe(*this.denom, rhs.num) ||
!mul_is_safe(*this.denom, rhs.denom)) {
return *this = safe_add(*this, rhs);
} else {
this->num = this->num*rhs.denom + this->denom*rhs.num;
this->denom *= rhs.denom;
this->reduce();
return *this;
}
}
Oder schenkt sich dadurch, dass 3 Mal mul_is_safe aufgerufen wird nicht viel?
hhmm keiner antwortet. Jetzt stellt sich die Frage wieso...
Zu unkonkret?
Bin ich sowieso komplett falsch?
Ist die Frage doof?
Wurde sie schonmal irgendwo beantwortet und ich habs übersehen?
Versteht keiner, was ich da mache(n) (will)?
Ich finde das frustrierend. Aber egal. Ich hab 2 Bücher, das Internet, und meinen hoffentlich gesunden Menschenverstand. Das werd ich wohl irgendwie auch alleine hinbekommen.
Bis dahin kann ich ja mal mich auf Anderes konzentrieren, z.B. Anwendung des brocot-stern-baums bzw der Kettenbruchentwicklung bei double-to-Rational
Edit: Ich hab grad auf die harte Tour einen Bug in der Funktion gefunden. Die sieht nämlich echt alt aus, wenn ich mit 0 multiplizieren möchte.
Jetzt muss ich überlegen, wie ich das behandle. Habs mir mal so überlegt:
bool mul_is_safe(int lhs, int rhs)
{
if (!lhs || !rhs) return true;
if (lhs > maxint / rhs || lhs < minint / rhs) return false;
return true;
}
Das ist denke ich gut begründet, da eine Multiplikation mit 0 immer 0 ergibt.
Also ich habe die Botschaft, dass hier niemand mehr schreibt, angenommen und entcheide das einfach selbst.
Ich hab nochmal über das nachgedacht, was Nathan gesagt hat, ich kann ja einen Integer Overflow provozieren und wenn ich das Programm starte crasht es auch nicht gleich.
Wenn das dann mit std::complex auch so ist, dann bin ich mir in meiner Entscheidung eigentlich ziemlich sicher: Die normalen Operatoren lass ich jetzt "unsicher". Aber ich lass mal die Funktionen drin, mit denen man "sicher" Addieren etc. kann.
Da ich mich schon etwas in diese Kettenbruchentwicklung eingearbeitet habe, werde ich versuchen das noch in diese Funktionen einzubauen, dass sie bei passendem bool Wert einen Bruch ausgeben, der näherungsweise das gleiche Ergebnis ist, aber halt nicht overflowed.
Das scheint für mich vorerst mal das Vernünftige zu sein, und ist ca. die Mitte zwischen den beiden Prinzipien.
In dem Fall ist das Thema für mich gegessen, danke an alle
