Discussion :

[astran]

Bonsoir,

J'ai un tableau bi-dimensionnel de calculs et lorsqu'une cellule est modifiée, si elle fait référence à une autre cellule le résultat de celle-ci doit être changé.
Pour cela, jai fait une simple boucle imbriquée for parcourant ce tableau afin de rafraîchir les résultats. Cela fonctionne, seulement voilà, au bout d'un moment j'obtiens un StackOverFlow. Alors, il y a-t'il des précautions à avoir lorsqu'on fait ce genre de boucle ?

Merci.

[Deaf]

Bonjour,

on peut supposer que ta méthode de rafraichissement s'appelle, plus ou moins directement, dès lors qu'elle modifie quelque chose et que tu dois modifier quelque chose à chaque fois qu'elle est appelée. Ce qui résulterait en un appel récursif sans fin et donc à ton StackOverFlow.

Mais tout cela reste de la divination. Pourrais-t-on avoir un peu de concret (genre, du code)?

[joel.drigo]

Salut,

on obtient une stackOverFlow lors du traitement lorsque la stack java est trop petite pour réaliser une boucle récursive. elle est forcément trop petite lors d'une boucle sans condition d'arrêt de récursion, comme dans l'exemple suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public int getValeur() {
     return getValeur();
}

ici la méthode getValeur() s'appelle elle-même : à chaque appel, on empile un contexte, et comme elle s'appelle elle même, elle s'appelle sans cese elle-même, jusqu'à ce qu'on dépasse les capacités de la pile

la précaution à prendre est donc de toujours veiller à avoir une condition d'arrêt qui est nécessaire vraie à un moment, tout en s'assurant de ne pas avoir un nombre de récursion trop importante pour la pile ou avoir une pile suffisamment grande.

dans ton cas, en particulier, il faut évider les appels "ping-pong", comme par exemple :

A1=A2+1;
A2=A1+1;

on peut détecter ce genre d'appel, en utilisant une pile par exemple qui mémorise chaque cellule utilisée, et qui renvoit une erreur particulière lorsqu'on détecte dans le set une cellule déjà utilisé : on affiche dans la cellule l'erreur à la place du bon résultat, afin d'avertir l'utilisateur que sa formule est incalculable

exemple bidon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
public class Cellule {
 
...
 
public ValeurCellule getValeur() {
     if ( isFormule() {
         return calcule(new HashSet<Cellule>());
     }
     else {
         return valeur;
     }
}
 
public Resultat calcule(Stack<Cellule> pileCellules) {
    List<Cellules> cellulesAppelees = getFormule().getCellules();
    for(Cellule celluleAppelee : cellulesAppelees ) {
        if ( pileCellules.contains(celluleAppelee) ) {
           return new ResultatErreur("appel récursif " +celluleAppelee); // condition d'arrêt
        }
        cellules.push(celluleAppelee);
    }
    try{
       return getFormule().calcule(cellules);
    }
     finally {
          for(Cellule celluleAppelee : cellulesAppelees ) {
              cellules.pop();
          }     
     }
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Formule {
 
     public Resultat calcule(Stack<Cellule> cellules) {
 
            List<Cellules> cellulesFormules=getCellules();
            List<ValeurCellule> resultats=new ArrayList<ValeurCellule>();
            for( Cellule cellule : cellulesFormules ) {
                ValeurCellule resultat=cellule.isFormule()?cellule.calcule(cellules):cellule.getValeur();
                if ( resultat instance Erreur ) {
                     return (Resultat)resultat,
                }
                resultats.add(resultat);
            }
            return calculeFormule(resultats);
     }
 
 
}

avec Resultat qui étend ValeurCellule et ResultatErreur qui étend Resultat bien sûr...

[astran]

Merci pour cette réponse détaillée, ça va nécessiter un temps d'étude et de tentatives sur Eclipse pour maitriser tout cela. Mais c'est ainsi qu'on apprend.