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?