Unendlich in C
In diesem Tutorial werden wir Unendlichkeit in C diskutieren. Wir beginnen mit der Diskussion über Unendlichkeit im Allgemeinen.
Als nächstes werden wir Unendlich als Laufzeitfehler in C diskutieren und mit einer Diskussion über das Speichern und Verwenden von Unendlich in C abschließen.
Was ist unendlich
Den Zahlenstrahl kennen wir alle aus unserer Grundschule. Dieser Zahlenstrahl wird durch Pfeile ohne Anfang und Ende dargestellt.
Aber theoretisch haben wir beide. Die Zahlen enden bei positivem ∞ (manchmal auch als +∞ geschrieben) unendlich und beginnen bei negativem unendlich -∞.
Jede reelle Zahl x liegt zwischen – ∞ < x < ∞. Infinity bezieht sich auf eine Zahl, deren Gewicht jenseits jeder beschreibbaren Grenze liegt.
Wenn wir sagen, dass wir unendlich viele Zahlen haben, bedeutet dies, dass wir eine unendliche Menge an Zahlen haben.
Wir alle wissen, dass wir, wenn wir eine Sache teilen, Stücke oder Teile der eigentlichen Sache erhalten. Je kleiner der Teiler, desto mehr Teile haben wir.
Um mehr Stücke zu bekommen, müssen wir das Ding in kleinere Stücke teilen. Wenn wir also etwas dividieren, das sich Null nähert, erhalten wir unendliche Teile (unzählige Teile).
Umgekehrt, wenn wir eine beliebige reelle Zahl durch unendlich dividieren, ist das Ergebnis Null, da es dasselbe ist, als würde man eine begrenzte Menge in unendliche Teile verteilen; dadurch erhält jedes Stück fast null Anteile.
Unendlichkeit in der Programmierung
Normalerweise haben Programmierer ein typisches Problem mit unendlich; Immer wenn der Teiler in einem Ausdruck Null ist (normalerweise aus Versehen), stürzt das Programm ab (abnormale Beendigung).
Eine anormale Beendigung kann ein ernsthaftes Problem für lebenswichtige Software sein. Die Programmierer wollen niemals eine anormale Beendigung; dabei werden die if-else-Prüfungen verwendet oder eine Ausnahmebehandlung durchgeführt.
Betrachten Sie einen einfachen Code:
#include <stdio.h>
int main() {
printf("%d\n", 5 / 0);
printf("\nEnd of program\n");
return 0;
}
In diesem Programm verwenden wir eine fest programmierte Division von 5 durch 0, um das Verhalten des Programms zu überprüfen; Es kann jedoch vorkommen, dass ein Programmierer eine Variable als Teiler verwendet, deren Wert irgendwie Null wird. Wir haben es im Programiz C Online-Compiler ausprobiert, und die Ausgabe ist unten.
Floating point exception
Wir haben denselben Code in einem anderen Online-Compiler ausprobiert, und die Ausgabe ist unten.
main.c: In function ‘main’:
main.c:3:23: warning: division by zero [-Wdiv-by-zero]
3 | printf ("%d\n", 5 / 0);
| ^
Dieses Programm wird bei der ersten print-Anweisung beendet (Absturz). Wir haben eine weitere print-Anweisung, die nicht ausgeführt wird, weil das Programm bereits beendet wurde (als abnormale Beendigung bezeichnet).
Darstellung der Unendlichkeit in C
In C wird unendlich durch INF oder inf dargestellt. Typischerweise ergibt es sich aus einer Division durch Null oder einen Nullwert.
Siehe diesen Beispielcode:
#include <math.h>
#include <stdio.h>
double divide(double d1, double d2) { return d1 / d2; }
int main() {
printf("Result: %lf\n", divide(2, 3));
printf("Result: %lf\n", divide(2, 0));
return 0;
}
Es gibt zwei print-Anweisungen im Code. Wir rufen die Funktion mit Nicht-Null-Parametern in der ersten print-Anweisung auf, während der zweite Parameter im zweiten print-Aufruf Null ist.
Ausgang:
Result: 0.666667
Result: inf
Die Situation kann ähnlich wie beim ersten Code aussehen; es ist jedoch etwas anders. Im ersten Code haben wir einen Ausdruck (der durch Null dividiert wurde) innerhalb der print-Anweisung, und als Ergebnis wird das Programm abnormal beendet.
Dieses zweite Programm ruft jedoch die Funktion divide von der Funktion main() auf. Die Funktion divide gibt als Ergebnis des Aufrufs der Funktion main inf zurück, die es entsprechend ausgibt.
Wir können die gleichen Ergebnisse erhalten, wenn wir das Ergebnis in einer Variablen in der Funktion main speichern.
#include <math.h>
#include <stdio.h>
double divide(double d1, double d2) { return d1 / d2; }
int main() {
double result = divide(2, 0);
printf("Result: %lf\n", result);
return 0;
}
Abgesehen davon, dass wir als Ergebnis inf erhalten, können wir das Ergebnis mit unendlich vergleichen. Unsere nächsten Anweisungen können auf dem Wert des Ausdrucks basieren, und viele Fälle erfordern, dass im Falle des unendlichen Ergebnisses nicht fortgefahren wird.
Daher müssen wir den Wert überprüfen, bevor wir die nächsten Anweisungen ausführen.
Zu diesem Zweck haben wir eine Funktion isinf, um zu prüfen, ob das Ergebnis unendlich ist oder nicht. Siehe das Beispiel:
#include <math.h>
#include <stdio.h>
double divide(double x, double y) { return x / y; }
int main() {
double res = divide(7, 3);
if (!isinf(res))
printf("Result is %lf\n", res);
else
printf("The result is infinity, and further computations not possible\n");
res = divide(7, 0);
if (!isinf(res))
printf("Result is %lf\n", res);
else
printf("The result is infinity, and further computations not possible\n");
return 0;
}
Beachten Sie die if-Anweisung, bei der wir unser Ergebnis an die isinf-Funktion übergeben, um das Ergebnis mit unendlich zu vergleichen. Wenn res einen unendlichen Wert hat, überspringen wir die printf-Anweisung.
Ausgang:
Result is 2.33333
The result is infinity, and further computations not possible
Aus der Ausgabe geht hervor, dass wir bei unendlichen Ergebnissen nicht weitermachen können; Das Programm führt jedoch keine abnormale Beendigung durch. In jedem Fall kann der Programmierer beliebige Daten speichern, Protokolle schreiben usw.
Negative Unendlichkeit in C
Wir haben auch negativ unendlich in C. Wenn wir zum Beispiel unendlich mit einer negativen Zahl multiplizieren, erhalten wir als Ergebnis negativ unendlich.
Siehe diesen einfachen Code:
#include <math.h>
#include <stdio.h>
int main() {
double res = -1 * INFINITY;
printf("Result is %lf\n", res);
return 0;
}
Die Ausgabe dieses Codes ist Ergebnis ist -inf. Schauen wir uns ein weiteres Beispiel an, um die Manipulationen mit -INFINITY zu verstehen.
#include <math.h>
#include <stdio.h>
double divide(double x, double y) { return x / y; }
int main() {
double res = divide(7, 3);
if (!isinf(res))
printf("Result is %lf\n", res);
else
printf("The result is infinity, and further computations not possible\n");
res = divide(-7, 0);
if (res != -INFINITY)
printf("Result is %lf\n", res);
else
printf(
"The result is negative infinity, and further computations not "
"possible\n");
return 0;
}
Hier fordert der zweite Funktionsaufruf der Funktion divide diese auf, eine negative Zahl durch 0 zu dividieren, wodurch ein Wert gleich minus unendlich zurückgegeben wird.
Ausgang:
Result is 2.33333
The result is negative infinity, and further computations not possible
In diesem Tutorial haben wir beide Aspekte behandelt. Zuerst haben wir die Methoden besprochen, um unsere Programme vor einer abnormalen Beendigung im Falle von unendlichen Ergebnissen zu bewahren.
Danach haben wir uns weiter angesehen, wie unsere Programme die Unendlichkeit weiter manipulieren können, um bedingte Ausdrücke mit unendlichen Werten zu entwickeln.