[boost] Re: std::exception -- Re: Re: Re: Re: Re:AttemptingresolutionofThreads&ExceptionsIssue

From: Eric Woodruff (Eric.Woodruff_at_[hidden])
Date: 2002-08-15 18:55:23

Since the compiler always creates its own instance of an exception when you
throw something, the following causes the invalid_argument to be sliced:

#include <iostream>
#include <stdexcept>

int main () {
        try {
                try {
                        throw std::invalid_argument ("argument is invalid");
                }
                catch (std::exception& exception) {
                        throw exception;
                }
        }
        catch (std::invalid_argument& exception) {
                std::cout << "invalid argument found" << std::endl;
        }
        catch (std::exception& exception) {
                std::cout << "generic std::exception found" << std::endl;
        }

        return 0;
}

This means that even with a valid std::exception& type caught from a thread,
it is impossible to have the user catch it as anything besides an
std::exception*. However, this may make it trivial to migrate to using
shared_ptrs of exceptions because the concrete exception types need not be
known, thus, a wrapper can easily be written to rethrow exceptions as
shared_ptrs.

The other option is to have to have disperate catching semantics for calls
to thread.join () and a non-threaded function. While the user can specify
that the thread supports std::exception&, they will have to catch an
std::exception* (the user isn't responsible for deleting it) -- this may or
may not be acceptable.

----- Original Message -----
From: Victor A. Wagner, Jr.
Newsgroups: gmane.comp.lib.boost.devel
Sent: Thursday, 2002:August:15 4:27 AM
Subject: Re: std::exception -- Re: Re: Re: Re:
Re:AttemptingresolutionofThreads&ExceptionsIssue

Thank you for the example.  I guess I hadn't paid as close attention to the
last paragraph of 14.3.1 of Stroustrup 3rd ed. as I thought.
At Wednesday 2002/08/14 10:53, you wrote:
>From: "Victor A. Wagner, Jr." <vawjr_at_[hidden]>
> > >
> > >Well, I am not a compiler writer, but it seems to me that to implement
> > >"throw;" and "catch", the compiler already needs a way to copy the
> > >exception, complete with its original type. :-)
> >
> > I don't see that at all.  The catch() clause specifies the type it's
> > expecting and it will be copied and sliced if need be to match.
>
>Quiz: what does this program do?
>
>#include <iostream>
>
>struct X
>{
>};
>
>struct Y: public X
>{
>};
>
>void f()
>{
>     try
>     {
>         throw Y();
>     }
>     catch(X)
>     {
// an exception will be caught here.
>        throw;
// an exception of type Y will be thrown.
>     }
>}
>
>int main()
>{
>     try
>     {
>         f();
>     }
>     catch(Y)
>     {
// an exception will be caught here.
>         std::cout << "Caught an Y!\n";
>     }
>}
>
>
>_______________________________________________
>Unsubscribe & other changes:
http://lists.boost.org/mailman/listinfo.cgi/boost

Victor A. Wagner Jr.      http://rudbek.com
PGP RSA fingerprint = 4D20 EBF6 0101 B069 3817 8DBF C846 E47A
PGP D-H fingerprint = 98BC 65E3 1A19 43EC 3908 65B9 F755 E6F4 63BB 9D93
The five most dangerous words in the English language:
               "There oughta be a law"

_______________________________________________
Unsubscribe & other changes:
http://lists.boost.org/mailman/listinfo.cgi/boost