Discussion :

[Estyros]

Bonjour !

Pour une raison biscornue encore non formalisée par moi, mais que j'exprimerai peut-être en fin de post si j'y arrive, j'en suis arrivé à me poser la question suivante :
Y a-t-il une gestion de la portée différente de d'habitude pour les objets qu'on lance avec throw ?

Bien évidemment, cette question que j'ai travaillée un bon moment peut tout de même ne pas être tout à fait représentative de mon interrogation. C'est pourquoi je vais mettre un peu de code. Imaginons donc une fonction principale qui va essayer de créer un objet dont le constructeur peut lever une exception.

Code :

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

1
2
3
4
5
6
7
8
9
void main_pyr(size_t const im0_size_x, size_t const im0_size_y) {
  try {
    Pyr pyr0(im0_size_x, im0_size_y);
  }
  catch(...) {
    ...gestion...
  }
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class Pyr {
  double *pyr_values;
public:
  Pyr(size_t const im_size_x, size_t const im_size_y) {
    if (une certaine condition n'est pas respectée) {
      throw "Paramètres non cohérents.";
    }
    ...on continue à initialiser l'objet...
  }
};

A priori, pas de soucis en vue (du moins je l'espère), même si je ne vois pas exactement ce qu'il se passe avec cette chaîne de caractères, mais c'est justement l'objet de ce post

Donc, mettons qu'au lieu de ce que j'ai écrit au dessus, nous ayons :

Code :

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

1
2
3
4
5
    if (une certaine condition n'est pas respectée) {
      string s = "Paramètres non cohérents.";
      throw s;
    }

L'objet s est déclaré localement dans ma boucle if, et pourtant, il semblerait que je sois capable de l'utiliser dans le catch de ma fonction principale. Est-ce normal ? Est-ce que le compilateur a corrigé quelque chose sans me le dire ?

Là où intervient vraiment mon problème, c'est que j'ai en réalité déclaré une classe MyException dérivant de la classe de base exception, définie ainsi (j'enlève toutes les fonctions sauf le constructeur) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class MyException : public exception
{
public:
  MyException(int number, char const *description, int level) throw()
    : m_number(number), m_what(description), m_level(level) {}
 
private:
    int m_number;
    char const *m_what;
    int m_level;
};

Notons que je suis débutant en C++ et que j'ai récupéré ce code dans un tutoriel trouvé sur Internet sans avoir aucun esprit critique. Donc si je comprends bien, notre MyException stocke simplement l'adresse de la chaîne de caractères servant à décrire l'erreur. On est sensé utiliser cette classe ainsi :

Code :

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

1
2
throw MyException(10,"Erreur 10 : paramètres incorrects.",1);

Or, ayant besoin de travailler sur la chaîne de caractères, je ne peux pas l'utiliser comme écrit ci-dessus. C'est là (enfin!) qu'arrive mon problème :
Cas 1 :

Code :

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

1
2
3
char *def = "Paramètres non cohérents.";
throw MyException(10,def,1);

Ca fonctionne !

Cas 2 :

Code :

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

1
2
3
string s = "Paramètres non cohérents.";
throw MyException(10,s.c_str(),1);

Ca ne fonctionne pas !

Donc je ne comprends pas :
1) Pourquoi le premier cas fonctionne.
2) Si le premier cas fonctionne bien et que c'est normal, pourquoi le deuxième cas ne fonctionne pas. Sachant que je ne suis pas choqué quant au fait que ça ne fonctionne pas.

Merci à tous ceux qui ont tenu le coup jusque là.

Bonne fin de journée !
Raphaël

[Médinoc]

Le cas 1 lance par valeur un objet contenant un pointeur vers une chaîne persistante.
Le cas 2 par contre, lance un objet contenant un pointeur vers une chaîne qui est détruire lors du déroulage de la pile (stack unwinding), c'est-à-dire entre la création de l'objet et sa réception par le catch.

En fait, si ton constructeur faisait une copie de la chaîne au lieu de mémoriser simplement le pointeur, ça marcherait.

[Kujara]

Le premier cas utilise un char * constant. Donc compilé avec ton programme, donc valable tout le temps.

Le deuxieme cas, très different :

string s = "Paramètres non cohérents.";

crée une string sur la stack, et la string recopie le char * constant.

s.c_str() <- ceci demande a la string de ressortir un char *. Mais attention, ce n'est pas celui d'origine.

throw MyException(10,s.c_str(),1);

Lors du throw, on sort du scope courant, donc on detruit toutes les variables de stack qui y ont etés crées, sauf celle qui est throw, bien sur. Du coup, s est detruit, donc le pointeur donnée a ton exception est invalide...

[Estyros]

D'accord ! C'est déjà plus clair ! Merci beaucoup.

Donc dans le premier cas, si j'ai bien compris vos deux réponses, le char *def pointe en fait sur une partie de mon programme, chargé en mémoire et fixe car le compilateur s'en occupe, au lieu de pointer sur la pile ? Et c'est un comportement défini dans la norme standard ? (Je ne sais pas tout à fait ce qu'on appelle norme standard, mais admettons).
Je ne savais pas du tout que ça se passait comme ça quand on écrivait une chaîne de caractères directement dans le programme. Je pensais que la chaîne était tout de même copiée sur la pile et qu'on pointait sur cette chaîne-ci (bien que ce ne soit évidemment pas intéressant).

Ca explique donc pourquoi, afin de ne pas avoir une nouvelle exception lorsque qu'on crée justement un objet exception, il est conseillé d'utiliser un char * au lieu d'un string ? Le premier ne pouvant plus planter si le programme s'est lancé.

Et qu'en est-il du

Code :

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

1
2
3
4
5
    if (une certaine condition n'est pas respectée) {
      string s = "Paramètres non cohérents.";
      throw s;
    }

Je crois que je ne comprends pas bien le comportement de throw. Car j'imagine ici que, bien que déclaré localement, l'objet s n'est pas détruit lorsqu'on sort de la fonction appelée pour retourner dans la fonction principale qui gèrera l'exception ?

Encore merci,

Raphaël

[Médinoc]

Je pense que l'objet s lui-même est détruit, mais qu'une copie de l'objet est lancée (donc, son constructeur de copie est appelée).

PS:

Code C/C++ :

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

1
2
char const *str = "abc"; //Données statiques
char str2[] = "abc"; //Sur la pile.

[loufoque]

Quand tu lances un objet, celui-ci est copié dans un endroit qui va bien.
Cet objet peut ensuite être copié autant de fois que l'implémentation le souhaite lors de la remontée des portées.

[Estyros]

D'accord ! Eh bien merci à tous pour ces éclaircissements qui m'aident beaucoup.

Passez une bonne journée !

Raphaël