Discussion :

[Pierre Levy]

Bonjour

Je demande de l'aide pour le problème suivant.

Après avoir defini une fonction, au sens mathématique du terme, je parcours une boucle dans laquelle pour une serie de valeurs de la variable x je calcule les valeurs correspondantes de ma fonction f(x).

Bien entendu si ma fonction contient une racine carrée d'un nombre négatif ou un denominateur qui s'annule mon programme est interrompu avec le message d'erreur approprié.

Est-il possible dans un cas comme celui-la de ne pas avoir d'interruption du programme et de continuer à parcourir la boucle de manière à obtenir toutes les valeurs existantes de f(x) ? Si oui comment faire ?

Je précise que j'ai fait des recherches dans les FAQs et sur Google, que je pense avoir saisi qu'il faut probablement utiliser un bloc "Try-Catch" ou "Try-Except" ou "Try-Finally", mais justement je n'arrive pas à comprendre comment le faire.

Mon but final est de tracer la représentation graphique de ma fonction.

Merci

[Patrick Seuret]

essaye comme ça:

Code :

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

1
2
3
4
5
6
7
8
9
for (double x=0;x<100;x=x+1) {
  try {
    double y=maFonction(x);
    DessinerFonction(x,y);
  }
  catch(...) {  // intercepte toute les exceptions
    // Ne rien faire
  }
}

La partie importante est de mettre le try...catch DANS la boucle for pour pouvoir continuer en cas d'exception.

[Pierre Levy]

Je suis confus de demander autant, mais c'est que je suis vraiment perdu.
Dans catch(...) que faut-il mettre à la place des points de suspension ?

Merci beaucoup pour les réponses.

[Patrick Seuret]

En fait, il faut les laisser tels quels. Mettre "..." signifie "capturer toutes les exceptions".

Si tu veux capturer une exception particulière (les exceptions sont des valeurs retournée, chacune avec son type), alors tu peux remplacer les "..." par le type d'exception. Il est possible de capturer plusieurs types d'exception en cascade en mettant plusieurs catch à la suite (mais un seul catch par type d'objet retourné par les exceptions).

exemple:

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
 
  try {
    if (value==0) throw 1;    // Ceci crée une exception de type "int"
    if (value<0)   throw 2;    // Aussi une exception de type "int"
    if (value>1000) throw "Trop grand"; // Une exception de type char*
  }
  catch(int aNumber) {
    // Ca catch capture toutes les exceptions qui sont des entiers
    if (aNumber==1) cerr<<"La valeur était zéro"<<endl;
    if (aNumber==2) cerr<<"La valeur était négative"<<endl;
  }
  catch(char* aText) {
    // Ce catch capture toutes les exceptions qui sont des char*
    cerr<<aText<<end;
  }
  catch(...) {
    // Ce catch capture toutes les exceptions qui n'ont pas déjà été prises$
    cerr<<"Erreur inattendue"<<endl;
  }

[Pierre Levy]

Merci pour les explications. Je crois que je commence à comprendre.
Les ... valent pour toutes les exceptions, mais semble-t-il seulement les exceptions standard du compilateur.
Mais celles d'un composant tiers ne sont pas interceptées.
J'utilise un composant non visuel qui évalue les formules mathématiques et dans ce cas les exceptions dont je parle au début ne sont pas interceptées.

[Patrick Seuret]

Pour ce que j'en sais, ce système intercepte toutes les exceptions qui sont générées par une "throw". Maintenant, il se peut que ton composant ne génère pas de telles exceptions mais affiche directement, de son propre chef, des messages d'erreur. Là, je ne vois pas comment l'en empêcher (peut-être y a-t-il une propriété du composant pour gérer les erreurs...)

[Pierre Levy]

C'est le cas. En effet mon composant affiche les erreurs dans une "MessageBox".

[Patrick Seuret]

Est-ce que tu ne pourrais pas faire les tests avant pour la validité des paramètres? Ou ta fonction est-elle trop complexe / inconnue ?

[Pierre Levy]

J'ai pensé à le faire, mais je ne vois pas comment car je veux obtenir mon tracé pour une fonction quelconque complexe ou pas, mais de toute manière définie dynamiquement à l'execution, d'où l'utilisation d'un composant pour analyser la formule.