Newsgroup: it.comp.lang.c++
Titolo: unexpected. E'una non conformità del VC++

Con il VC++ 6(no service packs)mi sono ritrovato a che fare con un
codice di questo tipo:
void calcola() throw(int,char*)
	{
	calcoli calc1(35,0);
	if(calc1.somma()<500)throw calcoli::errorelogico("minore di
500");
	}
Avendo specificato che fra la lista di eccezioni che può lanciare la
mia funzione non é contemplata calcoli::errorelogico, quindi secondo
lo standard il programma dovrebbe terminare con una unexpected(). Con
il VC++ invece l'eccezione é stata perfettamente intercettata da un
exception handler situata su main.
try
    {
    calcola();	
    }
catch(calcoli::errore &err1)
    {
    std::cout<<err1.descrivi()<<std::endl;
    }
Si tratta quindi di una non conformità del Visual C++?
Il Ghenio
-----
These are my parting words to you:
those who give up are doomed!
-----

 exception handler situata su main.
no.  non ho sottomano lo standard, ma mi per di ricordare che la
dichiarazione delle eccezioni lanciate non e' vincolante per il
programma.  ci sono state lunghe discussioni su questo nel ng
comp.lang.c++.moderated, e qui su it.comp.lang.c++ un lungo messaggio
di alex martelli in proposito (molto tempo fa).  come conseguenza, ho
smesso di dichiarare le eccezioni scrivendo c++ (cosa che facevo assai
coscienziosamente prima :-)
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

programma. 
Però lo Stroustrup afferma il contrario, ed altri compilatori( come il
MinGw o BCC55) si comportano in maniera differente facendo terminare
il programma anziché raccogliere l'eccezione.
Chi ha torto fra i due?


programma.
Sicuro? BS dice che il controllo delle specifiche delle eccezioni non
è richiesto solo tra diverse unità di compilazione.
-- 
                    Marco Barisione (ICQ 84277092)
Se sei interessato alla creazione di it.comp.lang (per i linguaggi di
programmazione senza un gruppo apposito e per i confronti fra i
linguaggi) partecipa alla discussione sul manifesto su it.news.gruppi.

di alex martelli in proposito (molto tempo fa).
Non ti ricordi qualcosa di più su questo messaggio? Ho provato a
cercarlo con Google ma non ho trovato nulla.


Dunque: a norma di standard dovrebbe effettivamente essere richiamata
std::unexpected() se una parte di codice lancia una eccezione non
dichiarata.  Ovviamente quello che fanno i vari compilatori non
serve come riprova, ma in ogni modo ho provato con questo pezzetto di
codice:
#include <iostream>
#include <stdexcept>
void fun() throw() {
  std::cout << "In fun()\n";
  throw std::runtime_error("ahi ahi");
}
int main() {
  try{
    fun();
  } catch (std::exception &e) {
    std::cout << "Eccezione: \"" << e.what() << "\"\n";
  }
  return 0;
}
namespace std {
  void unexpected() {
    cout << "In unexpected()\n";
    throw;
  }
};
Con KCC si comporta secondo le attese:
In fun()
In unexpected()
Eccezione: "ahi ahi"
Con g++ (3.0.2) no:
In fun()
Aborted (core dumped)
ma il motivo (dal debugger) e' che viene effettivamente richiamata una
funzione std::unexpected ma che ha una segnatura diversa dalla mia;
deve esserci nel prototipo di g++ per unexpected() un qualche
attributo (non-standard e caratteristico di g++) che non riesco ad
identificare.
A questo punto non so piu' cosa pensare; io ricordo chiaramente che
a suo tempo i guru del linguaggio hanno detto che e' inutile la
dichiarazione delle eccezioni, se non dannosa --- ma al momento non
riesco ad identificare la fonte.  Mi sono scorso tutto il 'guru of the
week', ho cercato con google, ma nulla da fare.  Mi spiace!


 riesco ad identificare la fonte.  
Il 2001-05-17 02:30:16 PST su it.comp.lang.c++ Alex Martelli scriveva, tra
le altre cose:
 
 >  Condivido, insomma, l'eccellente filosofia della
 >  Boost Library (
www.boost.org
):
 >  """
 >  Use exceptions to report errors where
 >  appropriate, and write code that is safe
 >  in the face of exceptions;
 >  Avoid exception-specifications.
 >  """
 Il messaggio completo è qui:
 
http://groups.google.com/groups?selm=9e05fu%242u6%241%40serv1.iunet.it
Per ulteriori dettagli in merito alla filosofia di Boost sulle eccezioni:
 
http://www.boost.org/more/lib_guide.htm#Exception-specification
Max


Reply-To: 
jack_...@bleading-edge.com
To: 
lor...@pd.infn.it
Cc: 
libs...@gcc.gnu.org
Subject: Re: How is unexpected() defined?
The KCC code is incorrect (which is suprising), the GCC result is as 
expected. There are several aspects here. First, 'unexpected' is a built-in 
function, which may, or may not, be replace-able by a client. You shouldn't 
try to replace it anyway. The correct way to change the behavior of 
'unexpected' is to create an 'unexpected_handler' function and call 
'set_unexpected' (this is similar to how a new handler is installed).
Second, if you dig further into the Standard, you will discover that while 
an unexpected handler may throw an exception, it still must be one that 
matches the exception specification of the function. This is reasonable 
since externally the exception specification has stated that only the 
exceptions specified will ever propagate out of the function. Since your 
'fun' has 'throw()' for the specification, then no exceptions can propagate 
from it and any attempt to do so - no matter how you go about it - should 
call terminate().
The default unexpeced handler is suppose to throw the standard exception 
'bad_exception' if that is allowed by the throw specification, otherwise it 
calls terminate().
------------------------------------------------------------------------
Chiaramente questo (anche se chiarisce il comportamento di g++) non
aggiunge nulla al capitolo "e' bene o male dichiarare le eccezioni".


 di alex martelli in proposito (molto tempo fa).
Quando? Potrei fare una ricerca su google ma mi sa che scrivere solo
exception specification tira fuori l'universo!
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556


Yes. VC supporta le exception specifications solo sintatticamente. Per
il resto le ignora. Vale anche per VC7. Le cose potrebbero migliorare
con la versione successiva (che si vocifera arriverà verso la fine del
2002).


 è richiesto solo tra diverse unità di compilazione.
Questo è un altro discorso. In pratica se in una translation unit io
scrivo:
void foo() throw();
void bar()
{
    foo();
}
e in un'altra scrivo:
void foo() throw( int )
{
    throw 1;
}
il compilatore non è obbligato a darmi un diagnostico in compile o link
time. Ma nel caso presentato dall'OP deve essere chiamata la
unexpected() che presumibilmente chiama la terminate().


 
L'item 14 di More Effective C++ parla proprio di questo
(use exception specifications judiciously)
Sostanzialmente dice che secondo lo standard e' legale invocare una 
funzione esterna per cui non sono specificate le eccezioni all'interno
di una funzione per cui invece sono specificate.
cioe' puoi avere:
extern void f1();
void f2() throw (int)
{
   f1();
}
Nota che in questo caso non ci sono incongruenze (nel senso che 
le specifiche di f1 non cambiano da un modulo all'altro).
Quindi la conclusione e' che o si speficicano le eccezioni *sempre*
e per *tutte* le funzioni che si invocano, oppure e' meglio lasciar
perdere la specifica delle eccezioni per non rischiare delle brusche
"terminazioni".
Io ho optato per la seconda (che non significa "ignorare" le eccezioni,
ma aspettarsi *tutte* le eccezioni)
A la prochaine,
Fabio
-- 
Posted from 
flopiano.mm.eutelsat.org
 [194.214.173.28] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

"terminazioni".
Oppure che se una funzione con una exception-specification chiama una
funzione che puň lanciare una eccezione non prevista da lei, la deve
trappare. Ovvero:
extern void f1();
void f2() throw (int)
{
    try {
       f1();
    }
    catch ( int ) {
        throw;
    }
    catch ( ... ) {
        // gestisci tutte le eccezioni diverse da int
        // non lanciare eccezioni che non siano int
    }
}
Naturalmente questo vale A MENO CHE non sia accettabile la chiamata di
unexpected con tutte le relative regole.


2002).
Confermo... e` documentato da MS e cmq lo so x esperienza diretta (ci
lavoro con quella specie di compilatore...).
Paolo

 e cmq lo so x esperienza diretta
Stai lavorando per una ditta di telefoni cellulari?  Sembrano i
messaggini di mia figlia...


messaggini di mia figlia...
No... e` che avendo tempi stretti ormai risparmio su tutto.
Ringrazia che almeno gli spazi continuo ancora a metterli...
Immaginasecominciassiascriverecosicomesarebbebello!!!!!   
Paolo