Discussion :

[Trunks]

Suite à un petit problème que j'ai rencontré, j'aimerais avoir davantage d'infos sur le mécanisme des exceptions en C++ et la durée de vie de variables.

Voici un exemple simple d'une exception:

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
class CMyException
{
public:
	CMyException(const char * message) throw() : m_message(message) {}
	~CMyException() throw() {}
 
	const char * what() const throw() { return m_message; }
 
protected:
	const char * m_message;
};
 
void f()
{
	char message[] = { "FooBar" };
	throw CMyException(message);
}

Code :

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

1
2
3
4
5
6
7
8
try
{
	f();
}
catch (CMyException &e)
{
	cout << "Message: " << e.what() << endl;
}

La variable message sort de la portée lorsqu'on se trouve dans le catch, donc son contenu susceptible d'être écrasé.

Voici la démonstration par le biais de la classe CMyString:

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
33
34
#include <iostream>
#include <ServiceMgr/StringHlp.h>
 
class CMyString
{
public:
	CMyString(const char * buffer) : m_buffer(strdup(buffer))
	{
		std::cout << "Constructeur de CMyString" << std::endl;
 
		m_buffer = new char[strlen(buffer) + 1];
		strcpy(m_buffer, buffer);
	}
 
	~CMyString()
	{
		std::cout << "Destructeur de CMyString" << std::endl;
 
		delete [] m_buffer;
		m_buffer = 0;
	}
 
	const char * c_str() const { return m_buffer; }
 
protected:
	char * m_buffer;
};
 
void g()
{
	CMyString str("Toto");
 
	throw CMyException(str.c_str());
}

Constructeur de CMyString
Destructeur de CMyString
Message: ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦└

Donc, est-ce incorrect de passer une variable temporaire comme argument de mon exception?

[white_tentacle]

Déjà :

Code :

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

1
2
3
4
5
6
7
CMyString(const char * buffer) : m_buffer(strdup(buffer))
	{
		std::cout << "Constructeur de CMyString" << std::endl;
 
		m_buffer = new char[strlen(buffer) + 1];
		strcpy(m_buffer, buffer);
	}

Tu fuis de la mémoire à chaque exécution de ton constructeur (strdup n'a rien à faire ici vu que tu alloues derrière avec new, utilise plutôt m_buffer(NULL) pour initialiser à null).

Ensuite, ton exception stocke un pointeur vers une chaîne de caractère, pas une chaîne de caractères elle-même. Donc, la libération de cet espace mémoire étant faite dans CMyString, le pointeur pointe vers de la mémoire libérée, bref, potentiellement n'importe quoi.

Il faut que ton exception soit "self-contained", qu'elle ne référence rien d'extérieur qui est susceptible de disparaître avant elle. À noter que son constructeur n'a pas besoin d'être throw(), donc tu peux très bien utiliser un new dedans.

[Trunks]

Déjà :



Tu fuis de la mémoire à chaque exécution de ton constructeur (strdup n'a rien à faire ici vu que tu alloues derrière avec new, utilise plutôt m_buffer(NULL) pour initialiser à null).

Oups, un vestige que j'ai oublié de supprimer, bien sûr, il faut enlever strdup() et mettre NULL à la place.

Ensuite, ton exception stocke un pointeur vers une chaîne de caractère, pas une chaîne de caractères elle-même. Donc, la libération de cet espace mémoire étant faite dans CMyString, le pointeur pointe vers de la mémoire libérée, bref, potentiellement n'importe quoi.

C'est fait exprès, c'était pour illustrer le problème de l'exception.

Il faut que ton exception soit "self-contained", qu'elle ne référence rien d'extérieur qui est susceptible de disparaître avant elle. À noter que son constructeur n'a pas besoin d'être throw(), donc tu peux très bien utiliser un new dedans.

Ah je pensais qu'une exception ne devait en aucun cas pouvoir générer une exception , d'où la necessité de ne pas utiliser de std::string.

Donc, comment tu écrirais la classe CMyException? Elle peut générer une exception?

[white_tentacle]

Elle ne doit pas lever d'exception dans son destructeur ni son constructeur de copie (potentiellement utilisé lors du catch, et c'est lui qui empêche l'usage de std::string), mais il me semble que dans un autre constructeur, tu as le droit.

Cela dit, je reste toujours dubitatif face à l'argument comme quoi tu ne dois pas utiliser de types dont le constructeur de copie peut lancer une exception. Une exception s'attrape par référence, pas par copie. D'ailleurs, l'exemple sur les exceptions de la FAQ cpp de développez... utilise une std::string .