Newsgroup: it.comp.lang.c++
Titolo: Sollevare eccezzioni

#include <iostream>
#include <string>
using std::cin;
using std::cout;
class ExceptionTest
{
	public:
		ExceptionTest(const std::string& var, const std::string& val)
     {
     	_var = "** Error in variable ";
     	_var += var;
     	_var += " whose value is ";
     	_var += val;
     	_var += " **\n";
     };
		~ExceptionTest(){};
		inline const char * what(){ return _var.c_str();};
	private:
  		std::string _var;	
};
int main(int argc, char *argv[])
{	
	int  i = 0;	
	try
	{	
		if(i == 0)
			throw ExceptionTest("i", "0");
	}
	catch(ExceptionTest e)
	{
		cout << e.what();
	}	
   char esc;
   cin.get(esc);
   return 0;
}
Questo è il mio test.
E corretto o c'è un modo per renderlo migliore???
-- 
Tnk
Luca "Kleidemos" Francesca
Un computer a un altro quando si incontrano:
"Ciao, come ti boota oggi???"

 E corretto o c'č un modo per renderlo migliore???
Suggerirei di derivare da std::exception (e, ovviamente, rendere 'const' il 
membro 'what').
Max

 Max
inline const char * what(){ return _var.c_str();};
Non lo è gia??
Cmq è leggibile e standard il mio code o derivando da std::exception 
sono + pulito???


 sono + pulito???
Il tuo codice è standard. Se, però, derivi i tipi delle eccezioni da 
'std::exception' puoi intercettarli tutti con un 'catch' limitato a 
'std::exception'. Questo in certi casi può essere utile. Ad esempio, in una 
situazione in cui hai vari tipi di eccezioni, potresti in determinate 
circostanze non avere l'esigenza di distinguere un tipo dall'altro, ma 
soltanto di intercettarli.
Max

 	catch(ExceptionTest e)
Ti conviene chiedere a qualcuno piu' esperto di me, ma ho l'impressione 
che probabilmente le eccezioni e' meglio "catcharle" :-) con reference, 
per attivare un eventuali late binding (soprattutto se hai una gerarchia 
nelle classi delle eccezioni).
Quindi, ci metterei una "&" :
catch (ExcpetionTest & e)
...
Dan

 soltanto di intercettarli.
Intendi na cosa simile:
#include <iostream>
#define HAVE_STRING
#ifdef HAVE_STRING
	#include <string>
#endif
using std::cin;
using std::cout;
/// Base class for extension
class BaseException
{
	public:
		/// Constructor
		BaseException(const std::string& var, const std::string& val)
     {
     	_msg = "** Error in ";
     	_msg += var;
     	_msg += " whose value is ";
     	_msg += val;
     	_msg += " **\n";
     };
     /// Virtual Destructor
		virtual ~BaseException() throw(){};
		/// What function whitch have to redefinig in derived class
		virtual inline const char * what() const throw(){return _msg.c_str();};
	protected:
  		std::string _msg;	
};
class DerivedException : public BaseException
{
	public:
		/// Constructor
		DerivedException(const std::string& var, const std::string& val)
     : BaseException(var, val)
     {
     	_msg += " From DerivedException\n\n";
     };
     /// Virtual Destructor
		~DerivedException() throw(){};
		/// What function whitch have to redefinig in derived class
		inline const char * what() const throw(){return _msg.c_str();};
};
void foo(int a)
{
	if(a == 0)
			throw BaseException("Parameter (int)a", "0");
}
void bar(void* ptr)
{
	if(ptr == NULL)
			throw DerivedException("Parameter (void *)ptr", "NULL");
}
int main(int argc, char *argv[])
{	
	int i = 0;	
	int *a = NULL;
	try
	{	
		// foo(i); // for Base
		bar(a); // for Derived
	}
	catch(BaseException& e)
	{
		std::cerr << e.what();
	}	
 
   char esc;
   cin.get(esc);
   return 0;
}
-- 
