Quelle est la valeur de i while (i == i + 1) {} boucle indéfiniment?

J'ai traversé ce casse-tête à partir d'un cours de programmation avancé lors d'un examen universitaire britannique .

Considérez la boucle suivante, dans laquelle i est, jusqu'à présent, non déclaré:

while (i == i + 1) {}

Trouvez la définition de i, qui précède cette boucle, de telle sorte que la boucle while continue pour toujours.

La question suivante, qui posait la même question pour cet extrait de code:

while (i != i) {}

était évident pour moi. Bien sûr, dans cette autre situation, c'est le cas, NaNmais je suis vraiment coincé sur la précédente. Est-ce que cela a à voir avec le débordement? Pourquoi une telle boucle ferait-elle une boucle éternelle en Java?

Tout d'abord, puisque la while (i == i + 1) {}boucle ne change pas la valeur de i, rendre cette boucle infinie équivaut à choisir une valeur de iqui satisfait i == i + 1.

Il existe de nombreuses valeurs de ce type:

Commençons par les "exotiques":

double i = Double.POSITIVE_INFINITY;

ou

double i =  Double.NEGATIVE_INFINITY;

La raison pour laquelle ces valeurs satisfonti == i + 1 est indiquée dans
JLS 15.18.2. Opérateurs additifs (+ et -) pour les types numériques :

La somme d'une infinité et d'une valeur finie est égale à l'opérande infini.

Cela n'est pas surprenant, car l'ajout d'une valeur finie à une valeur infinie devrait entraîner une valeur infinie.

Cela dit, la plupart des valeurs de iqui satisfont i == i + 1sont simplement des valeurs grandes double(ou float):

Par exemple:

double i = Double.MAX_VALUE;

ou

double i = 1000000000000000000.0;

ou

float i = 1000000000000000000.0f;

Les types doubleet floatont une précision limitée, donc si vous prenez une valeur doubleou assez grande float, l'ajout 1de celle-ci donnera la même valeur.

Ces puzzles sont décrits en détail dans le livre "Java Puzzlers: Traps, Pitfalls, and Corner Cases" de Joshua Bloch et Neal Gafter.

double i = Double.POSITIVE_INFINITY;
while (i == i + 1) {}

ou:

double i = 1.0e40;
while (i == i + 1) {}

les deux résulteront en une boucle infinie, car l'ajout 1d'une valeur à virgule flottante suffisamment grande ne changera pas la valeur, car elle ne «comble pas l'écart» avec son successeur ¹ .

Une note sur le deuxième puzzle (pour les futurs lecteurs):

double i = Double.NaN;
while (i != i) {}

entraîne également une boucle infinie, car NaN n'est égal à aucune valeur à virgule flottante, y compris lui-même ² .

^{1 - Puzzlers Java: pièges, pièges et cas de coin (chapitre 4 - Puzzlers Loopy).}

^{2 - JLS §15.21.1}

double i = Double.POSITIVE_INFINITY;

Juste une idée: qu'en est-il des booléens?

bool i = TRUE;

N'est-ce pas un cas où i + 1 == i?